Programação - Coding Mobile (Java) - 3

Prévia do material em texto

Unidade III
Gerenciando app Android
Introdução ao 
Coding Mobile
Diretor Executivo 
DAVID LIRA STEPHEN BARROS
Gerente Editorial 
CRISTIANE SILVEIRA CESAR DE OLIVEIRA
Projeto Gráfico 
TIAGO DA ROCHA
Autoria 
LUIZ FERNANDO CORCINI
AUTORIA
Luiz Fernando Corcini
Olá. Meu nome é Luiz Fernando Corcini. Sou formado em 
Engenharia Eletrônica, com especialização em Administração de 
TI, Mestre em Educação e Novas Tecnologias e Doutorando em 
Sistemas Tutores Inteligentes. Tenho experiência técnico-profissional 
na área de desenvolvimento e gestão da produção de softwares nas 
áreas de Gerenciamento de Processos Empresariais. Uso os recursos 
disponibilizados pela Web há mais de 20 anos. Sou professor universitário 
há mais de 15 anos e já publiquei vários livros técnicos sobre assuntos 
voltados a área de informática. Sou apaixonado pelo que faço e adoro 
transmitir minha experiência de vida àqueles que estão iniciando em 
suas profissões. Por isso fui convidado pela Editora Telesapiens a integrar 
seu elenco de autores independentes. Estou muito feliz em poder ajudar 
você nesta fase de muito estudo e trabalho. Conte comigo!
ICONOGRÁFICOS
Olá. Esses ícones irão aparecer em sua trilha de aprendizagem toda vez 
que:
OBJETIVO:
para o início do 
desenvolvimento 
de uma nova 
competência;
DEFINIÇÃO:
houver necessidade 
de apresentar um 
novo conceito;
NOTA:
quando necessárias 
observações ou 
complementações 
para o seu 
conhecimento;
IMPORTANTE:
as observações 
escritas tiveram que 
ser priorizadas para 
você;
EXPLICANDO 
MELHOR: 
algo precisa ser 
melhor explicado ou 
detalhado;
VOCÊ SABIA?
curiosidades e 
indagações lúdicas 
sobre o tema em 
estudo, se forem 
necessárias;
SAIBA MAIS: 
textos, referências 
bibliográficas 
e links para 
aprofundamento do 
seu conhecimento;
REFLITA:
se houver a 
necessidade de 
chamar a atenção 
sobre algo a ser 
refletido ou discutido;
ACESSE: 
se for preciso acessar 
um ou mais sites 
para fazer download, 
assistir vídeos, ler 
textos, ouvir podcast;
RESUMINDO:
quando for preciso 
fazer um resumo 
acumulativo das 
últimas abordagens;
ATIVIDADES: 
quando alguma 
atividade de 
autoaprendizagem 
for aplicada;
TESTANDO:
quando uma 
competência for 
concluída e questões 
forem explicadas;
SUMÁRIO
Ciclo de vida do aplicativo Android e a Classe Activity ............. 10
Introdução ............................................................................................................................................. 10
Gerenciando aplicativos .............................................................................................................. 11
Ciclo de vida do aplicativo Android ................................................................................... 12
A Classe Activity ............................................................................................................................... 15
Navegabilidade ............................................................................................23
Introdução .............................................................................................................................................23
Chamando a segunda Activity ...............................................................................................27
Intenção de chamada ...............................................................................................27
Evento de chamada ..................................................................................................28
Passagem de parâmetros entre telas ................................................ 31
Inserindo componentes na tela ........................................................... 37
Entendendo o Editor de Layout ........................................................................................... 38
TextView .................................................................................................................................................43
Pain Text .................................................................................................................................................47
Button ..................................................................................................................................................... 49
Radio button ....................................................................................................................................... 50
Check box e Combo box ...........................................................................................................53
7
UNIDADE
03
Introdução ao Coding Mobile
8
INTRODUÇÃO
Seja bem-vindo(a) à Unidade 3 – Gerenciando app Android, da 
disciplina de Introdução ao Coding (Mobile). Nesta unidade usaremos os 
conhecimentos adquiridos nas duas primeiras unidades e aprenderemos 
a criar e gerenciar uma aplicação básica em Java-Android. O conteúdo 
desta Unidade está dividido em quatro módulos. No primeiro módulo, 
você entenderá como funciona o ciclo de vida da aplicação mobile android 
e como implementar uma classe Activity. No módulo 2, estudaremos 
sobre navegabilidade, isto é, como implementar uma aplicação android 
com várias telas e como fazer uma tela chamar a outra. No terceiro, 
aprenderemos a passar parâmetros entre uma tela e outra da aplicação, 
permitindo assim uma aplicação mais complexa e robusta. Finalmente, 
no módulo 4, veremos como inserir alguns dos componentes básicos em 
uma aplicação Android, para que a mesma fique mais interativa. É claro 
que existe muito mais para aprender, mas o aprofundamento de cada 
um destes conhecimentos pode ser feito acessando os links indicados 
durante o texto, no tópico [Saiba Mais]. Vamos começar? Excelente estudo 
para você!
Introdução ao Coding Mobile
9
OBJETIVOS
Olá. Seja muito bem-vindo(a) a nossa Gerenciando app Android, o 
objetivo é auxiliar você no desenvolvimento das seguintes competências 
profissionais até o término desta etapa de estudos:
1. Entender o ciclo de vida de um aplicativo desenvolvido para Android 
e à classe Activity;
2. Aplicar os recursos da linguagem Java, para proporcionar a 
navegabilidade de aplicativos para dispositivos móveis, baseados no 
Android;
3. Compreender como transmitir parâmetros entre as telas de um 
aplicativo desenvolvido na linguagem Java para dispositivos móveis 
Android;
4. Formatar telas de aplicativos para dispositivos móveis baseados 
no sistema operacional Android.
Vamos, então, rumo ao conhecimento. Bons estudos!
Introdução ao Coding Mobile
10
Ciclo de vida do aplicativo Android e a 
Classe Activity 
Agora que você já está com os ambientes de desenvolvimentos 
Java-Android instalados e configurados em seu computador (visto na 
Unidade 1) e já tem certa familiaridade com a linguagem Java (visto na 
Unidade 2), podemos na Unidade 3 chegar ao entendimento de como 
funcionam as apps Android.
Introdução
A maioria das aplicações Android necessita de uma interface que 
permita a interação com o usuário. Conhecida também como UI (user 
interface), ela pode ser formada por uma ou mais telas, onde devem ser 
apresentados os elementos (botões, caixas de texto, figuras, animações, 
caixas de seleção etc.). É importante destacar que cada atividade (classe 
activity) representa uma única tela (UI) do aplicativo e é responsável por 
gerenciar (tratar) os eventos que o usuário pode gerar em cada um dos 
elementos apresentados nela, como por exemplo, o ato de clicar em um 
botão, digitar um texto ou selecionar um item. 
Para o caso de aplicações que precisem ter mais de uma tela, será 
necessário ter mais de uma atividade, ou seja, é necessário implementar 
uma atividade para cada tela. Por exemplo, um aplicativo de e-mail deve 
ter uma atividade que mostre a lista de e-mails, outra responsável por 
permitir que o usuário digite um novo e-mail e ainda outra com a função 
de mostrar o conteúdo do e-mailpara que o usuário possa lê-lo. Apesar 
das atividades de uma mesma aplicação trabalharem juntas para compor 
as funcionalidades de um aplicativo, elas são independentes umas 
das outras e podem, caso a configuração do aplicativo permita, serem 
iniciadas individualmente.
Uma característica especial dos aplicativos do Android é que uma 
aplicação pode iniciar qualquer componente instalado no aplicativo e 
utilizar seus recursos, se assim estiver configurado. 
Introdução ao Coding Mobile
11
SAIBA MAIS:
Uma nova aplicação pode precisar capturar uma foto 
utilizando o dispositivo de câmera. Esta nova aplicação 
pode utilizar um aplicativo existente para realizar essa 
tarefa e capturar o resultado sem ter que implementá-la, 
isto é, utilizando os recursos de uma aplicação já existente. 
Para tanto, a nova aplicação precisa apenas ser capaz de 
iniciar a atividade de captura de foto da outra aplicação, 
sem a necessidade de incorporá-la ou de estar ligada 
a ela de alguma forma. Deste modo, quando a atividade 
de captura de foto for finalizada, a foto é retornada para 
a nova aplicação e pode ser tratada e utilizada como o 
programador determinar. 
Um detalhe importante a se considerar é que, pelo fato de cada 
aplicação rodar em processos separados, com restrição de acesso, uma 
aplicação não pode iniciar diretamente outra. Para fazer isto, ela manda 
uma mensagem para o sistema Android indicando a intenção de iniciar a 
outra atividade e este sim pode decidir se atende ou não a essa intenção. 
Cada mensagem de intenção passada para o sistema Android é chamada 
de “intent” e será tratada em detalhes mais adiante, neste material, bem 
como os processos de ativação de componentes.
Gerenciando aplicativos
É importante entender que os dispositivos móveis precisam gerenciar 
cuidadosamente a utilização de seus recursos, principalmente a memória, 
pois normalmente, tais recursos são bem limitados. O sistema operacional 
gerencia as aplicações na forma de uma pilha – stack applications ou, em 
português, pilha de aplicações. A aplicação que está no topo da pilha é 
a que está sendo executada e visualizada. As outras permanecem com 
status de “paradas temporariamente” (pause) ou “paradas definitivamente” 
(stop) e não podem ser visualizadas até que voltem a estar no primeiro 
lugar, no topo da pilha. O aplicativo com status pause ou stop pode, a 
qualquer momento, ser descartado (encerrado) pelo sistema operacional 
Introdução ao Coding Mobile
12
para liberar mais memória, em casos em que a utilização desse recurso 
atinja um limite crítico.
Cada aplicativo tem seu ciclo de vida bem definido e pode ter vários 
estados (status) desde o início de sua execução até ser descartado pelo 
usuário ou pelo próprio sistema operacional. O tópico a seguir apresenta 
como funciona o ciclo de vida de uma aplicação.
Ciclo de vida do aplicativo Android
Para os dispositivos móveis que utilizam a plataforma Android, o 
ciclo de vida dos aplicativos deve seguir as seguintes etapas:
Quando o usuário clica sobre o ícone da aplicação, ela é criada e 
passa a utilizar recursos do sistema operacional do dispositivo. O termo 
“criar” (create), neste contexto, não tem o sentido de “implementar” ou 
“desenvolver”, mas sim de “instanciar”, isto é, ser executado e passar a 
ocupar um espaço de memória e utilizar recursos do sistema. 
 • Quando um aplicativo é executado, ele chama o método onCreate, 
que é obrigatório e é executado uma única vez durante o ciclo de 
vida da aplicação. 
 • Esse método define o que deve ser feito, qual a interface utilizada e 
quais os componentes dessa interface.
Para entrar em operação e poder ser utilizado, o aplicativo, depois 
de criado, precisa ser iniciado. Quando isto acontece, o método onStart 
é chamado. Ele não é obrigatório, mas pode-se utilizá-lo para capturar o 
evento de inicialização da aplicação. 
O aplicativo deve, então, ser colocado no topo da pilha de aplicativos, 
para poder ser visualizado e controlado pelo usuário. Esse evento pode 
ser capturado pelo método onResume.
Caso outro aplicativo seja iniciado, o aplicativo anterior é parado 
temporariamente (paused) e vai para o segundo lugar da pilha de 
aplicativos. Este evento é capturado pelo método onPause, que pode ser 
implementado para salvar o estado (atributos) do aplicativo, antes que ele 
passe para a situação de parado temporariamente. Esse é um método 
Introdução ao Coding Mobile
13
muito útil, pois, caso a aplicação volte ao topo da pilha, é necessário 
saber qual era a sua situação e quais eram seus dados antes de ser 
temporariamente parado.
 • Para voltar a utilizar o aplicativo que está parado temporariamente, 
este deve voltar ao topo da pilha. Mas isso só acontece se o outro 
aplicativo que tomou seu lugar no topo da pilha for descartado 
ou parado temporariamente. Quando isso acontece, o método 
onResume entra em ação novamente.
O aplicativo que está parado temporariamente (paused) pode ser 
parado definitivamente (stop). O método que captura este evento é o onStop.
 • Uma vez parado, o usuário só conseguirá utilizar novamente o 
aplicativo se reiniciá-lo. Se isso acontecer, o método onRestart 
será chamado, capturando assim o evento e passando o controle 
para o método onStart.
O aplicativo pode, depois de parado, ser retirado da pilha, isto é, ser 
descartado. Quando isso acontece, o método onDestroy é chamado e o 
ciclo de vida da aplicação termina. 
 • Para ter acesso a esse aplicativo depois dele ter sido retirado da 
pilha, o usuário deve recriá-lo, fazendo com que outro ciclo de 
vida tenha início. 
O diagrama de transição de estado, abaixo, representa este ciclo:
Figura 1 – Ciclo de Vida dos Aplicativos Android
CRIADO
DESTRUÍDO
INICIADO
EM 
EXECUÇÃO
PARADO 
TEMPORARIAMENTE
PARADO 
DEFINITIVAMENTE
1
2
3 4 6
9 8
10
5
Fonte: Autor
Introdução ao Coding Mobile
14
Para o entendimento da figura acima, segue a legenda: 
1. método onCreate – chamado quando o usuário clica sobre o ícone 
da aplicação; 
2. método onStart – chamado quando a aplicação se torna visível 
para o usuário; 
3. método onResume – chamado quando a aplicação está no topo 
da pilha; 
4. método onPause – chamado quando a aplicação sai do topo da 
pilha e fica parada temporariamente, por causa da execução de 
outra aplicação; 
5. método onResume – chamado quando a aplicação que foi parada 
temporariamente volta a ser requisitada; 
6. método onStop – chamado quando a aplicação está sendo 
encerrada; 
7. método onRestart – chamado quando a aplicação precisa ser 
iniciada outra vez; 
8. método onDestroy – chamado para encerrar a execução da 
aplicação; 
9. método onDestroy – neste caso, a aplicação está sendo encerrada 
não pelo usuário, mas sim pelo SO para liberar memória; 
10. aplicação descartada. 
Todos esses métodos listados acima fazem parte da classe activity, 
que é utilizada pelo sistema operacional Android para ajudar a gerenciar 
esse ciclo de vida dos aplicativos. O tópico a seguir apresenta mais 
detalhes sobre esta classe.
Introdução ao Coding Mobile
15
A Classe Activity
A classe activity define as atividades do projeto. É a classe mãe ou 
a superclasse que define as características e os comportamentos básicos 
para qualquer atividade criada para o projeto. Cada atividade é responsável 
por fornecer uma tela onde o usuário pode interagir para realizar alguma 
ação, como digitar um número de telefone, tirar uma foto, ler um e-mail, 
incluir, alterar ou excluir os dados de um contato. A interface criada na 
atividade pode preencher a tela inteira do dispositivo, o que normalmente 
acontece, ou pode flutuar sobre outras telas.
Com base no exposto nos itens anteriores, sobre os métodos do 
ciclo de vida de um app Android, a Classe Activity pode ser representada, 
segundo o padrão UML, da seguinte maneira:
Figura 2 – Representação gráfica da Classe Activity
CLASSE Activity
...
onCreate()
onStart()onResume()
onPause()
onRestart()
onStop()
onDestroy()
...
Fonte: Autor
Fonte: adaptado pelo autor, no app do android. Naturalmente, como 
não se tratou dos atributos, a lista de atributos da classe Activity ainda é 
desconhecida, por isso foi colocada como sendo “...”. Da mesma forma, 
pode ser que a classe activity tenha mais métodos que os mencionados; 
por isso, após o método onDestroy, também foi colocado “...”. 
EXEMPLO
Abra o Android Studio e crie um novo projeto, clicando no item “Start 
a new Android Studio Project”, destacado em vermelho na figura abaixo:
Introdução ao Coding Mobile
16
Figura 3 – Criando um novo projeto Android
Fonte: app Android (2018)
Defina o nome da aplicação como App1_U3, a dizer que esta é 
nossa primeira aplicação criada na Unidade 3 desta disciplina, conforme 
mostrado na figura abaixo:
Figura 4 – Definindo o nome da aplicação
Fonte: app Android (2018)
Introdução ao Coding Mobile
17
Deixe os demais campos como estão e clique em “Next”. A tela a 
seguir deve ser apresentada:
Figura 5 – Definindo o dispositivo Android para o projeto
Fonte: app Android (2018)
Marque a opção “Phone and Tablet” e selecione a “API15”, como 
mostrado na figura acima e clique em “Next”.
IMPORTANTE:
Caso você não se recorde o motivo pelo qual está a fazer 
estas seleções, reveja o material da Unidade 1 desta 
disciplina.
A tela a seguir deve aparecer:
Introdução ao Coding Mobile
18
Figura 6 – Adicionando a Activity para o projeto
Fonte: app Android (2018)
Selecione a “Empty Actvity” e clique em “Next”. A tela a seguir deve 
ser apresentada;
Figura 7 Configurando a Activity
Fonte: app Android (2018)
Introdução ao Coding Mobile
19
Deixe os nomes como estão e clique em “Finish”. O projeto será carregado.
O Código da classe Activity do projeto deve ser como mostrado na 
figura abaixo:
Figura 8 – Classe Activity do projeto
Fonte: app Android (2018)
Com os conhecimentos que você adquiriu na Unidade 2 sobre 
linguagem Java, você pode entender o código acima, senão vejamos:
 • A linha 1 define o pacote onde se encontra a classe Activity que 
estamos a visualizar;
 • A linha 6 declara a classe MainActivity (Atividade principal) que irá 
gerenciar a tela principal do nosso aplicativo, pois, conforme vimos 
anteriormente, neste material, cada tela é gerenciada por uma classe 
Activity.
Importante também verificar que a classe MainActivity herda 
(extends) características e comportamentos da classe AppCompatActivity.
 • Na linha 8 existe uma expressão a informar que o método abaixo 
é uma sobrescrita. Usa-se @Override toda vez que você substituir 
um método. Seu uso, conforme Singh (2017), fornece dois 
benefício: (1) Para ter certeza que você realmente está a substituir 
o método que deseja, pois, caso você cometa um erro comum ao 
digitar incorretamente um nome de método ou não corresponder 
corretamente aos parâmetros, você será avisado de que o método 
não substitui como você pensa. (2) Torna o seu código mais 
fácil de entender, porque é mais óbvio quando os métodos são 
sobrescritos.
Introdução ao Coding Mobile
20
 • A linha 9 mostra o método onCreate sendo declarado. Este é o 
método que copia o método da classe mãe AppCompatActivity.
 • Na linha 10 ocorre a chamada ao método onCreate da classe mãe;
 • Na linha 11 é definido o layout para a activity que está a ser criada.
Verificando o conteúdo da classe MainActivity, descrita acima, 
pode-se perceber que apenas o método onCreate está sendo utilizado, 
pois ele é o único obrigatório. Como vimos acima, existem outros seis 
métodos que completam o ciclo de vida de uma aplicação, que podem 
ser utilizados para permitir ao programador maior controle sobre a 
aplicação que está desenvolvendo. 
Se você executar a aplicação, o resultado deve ser o mostrado na 
figura abaixo:
Figura 9 – AVD da execução do projeto
Fonte: app Android (2018)
Introdução ao Coding Mobile
21
Exemplo a seguir apresenta o código que deve ser implementado no 
seu projeto (na classe MainActivity) para dar uma noção do funcionamento 
da atividade quando a mesma possui todos os métodos para o controle 
do ciclo de vida da aplicação.
Implemente o seguinte código na sua classe MainActivity:
Figura 10 – Exemplo dos métodos de gerenciamento de aplicações de app Android
Fonte: app Android (2018)
O código acima não tem função prática alguma, a não ser permitir 
que você entenda o funcionamento do gerenciamento do ciclo de vida de 
aplicativos Android. Salve e execute a aplicação. Para verificar o resultado, 
abra a janela chamada “Run”, como mostrado na figura abaixo e verifique 
os itens destacados em vermelho.
Introdução ao Coding Mobile
22
Figura 11 – Resultado da execução do código do exemplo.
Fonte: app Android (2018)
O AVD deve estar como mostra a figura abaixo:
Figura 12 – AVD do exemplo
Fonte: app Android (2018)
Para verificar o resultado da execução dos métodos, clique em um 
dos botões destacados em vermelho (na figura acima).
IMPORTANTE:
Compare o resultado apresentado na janela “Run” com o 
diagrama de transição de estado (figura 1).
Introdução ao Coding Mobile
23
Navegabilidade
Introdução
Aplicativos mais complexos normalmente possuem mais de uma 
tela ou precisam chamar outros aplicativos para executarem uma função 
especializada. Este tópico mostra como criar novas telas (activity) para um 
mesmo aplicativo, como navegar entre elas e também como permitir que 
a tela de um aplicativo (activity) chame outro aplicativo (activity).
Os métodos utilizados para iniciar uma nova (tela) activity são os 
seguintes: startActivity e startActivityForResult. 
Lembre-se de que cada tela de um aplicativo é uma classe Activity 
e que a linguagem Java diferencia letras maiúsculas de letras minúsculas. 
Dessa forma, o método “startActivity” não pode ser escrito como: 
“startactivity”. 
A decisão da utilização de um desses dois métodos deve recair 
sobre a seguinte questão: a tela (activity1) que está chamando a outra 
(activity2) precisa de algum retorno ou vínculo para poder continuar suas 
atividades, depois que a tela chamada (activity2) for fechada? Em caso de 
resposta positiva, deve-se utilizar o método startActivityForResult. Mas se 
esse não for o caso e a tela (Activity1) que está chamando a outra (activity2) 
não precisar de nenhum vínculo ou retorno, deve-se utilizar o método 
startActivity. As figuras abaixo representam graficamente esses dois casos:
 • Uso do método startActivity
Figura 13 – A Activity1 não precisa de retorno da Activity2, depois que a última for fechada e 
o foco retornar para a primeira.
Fonte: app Android (2018)
Introdução ao Coding Mobile
24
 • Uso do método startActivityForResult:
Figura 14 – A Activity1 precisa de retorno da Activity2, depois que a última for fechada e o 
foco retornar para a primeira.
Fonte: app Android (2018)
Para entender melhor algumas características necessárias para a 
correta navegabilidade entre telas de um aplicativo Android, verifique o 
exemplo a seguir:
Crie um novo projeto Android, chamado App2_U3 nos mesmos 
moldes que o App1_U3. Para fazer isso você pode fechar o projeto App1_
U3, que está aberto ou, selecionar a opção do menu File->New -> New 
Project..., como mostra a figura abaixo:
Figura 15 – Criando o projeto App2_U3
Fonte: app Android (2018)
Note que este novo projeto, a exemplo do anterior, possui apenas 
uma activity (tela), chamada de MainActivity ou tela principal. ....... Crie mais 
duas telas (Empty Activity) dentro do novo projeto (pacote App2_U3) com 
as seguintes características:
 • Primeira tela: Nome da Atividade: Tela2;
 • Segunda Tela:Nome da Atividade: Tela3.
Para fazer isso, clique com o botão direito do mouse sobre a app e 
selecione new->Activity->Empty Activity, conforme mostra a figura abaixo:
Introdução ao Coding Mobile
25
Figura 16 – Inserindo nova activity no projeto
Fonte: app Android (2018)
O seu projeto deve ficar como mostraa figura abaixo:
Figura 17 – Projeto com três activity ou telas
Fonte: app Android (2018)
Salve, execute o projeto e verifique se apenas a atividade principal 
fica visível e as duas outras atividades (tela2 e tela3) não estão acessíveis. 
Para verificar o por que disso acontecer, precisamos analisar o arquivo 
AndroidManifest.xml, que deve estar como o código mostrado a seguir:
Introdução ao Coding Mobile
26
Figura 18 – Arquivo AndroidManifest.xml do projeto App2_U3.
Fonte: app Android (2018)
Repare que apenas a atividade principal (MainActivity), na linha 12, 
possui o <intent-filter>. Este fragmento de código tem dois atributos: (1) 
ação (action), cuja função é definir se a atividade pode ser uma atividade 
principal do aplicativo. (2) categoria (category), que define se o usuário 
pode iniciar a atividade diretamente, do menu de aplicativos.
NOTA:
Para ter acesso ao menu de aplicativos basta clicar sobre 
a região marcada em vermelho, na figura abaixo, e arrastar 
para cima. Os aplicativos implementados até o momento 
estão destacados em azul.
Introdução ao Coding Mobile
27
Figura 19 – Abrir o menu de aplicativos
Fonte: app Android (2018)
Chamando a segunda Activity
Intenção de chamada
Para chamar a segunda tela (atividade) da aplicação, é necessário 
utilizar o objeto Intent. Esse objeto será descrito em detalhes no próximo 
módulo, portanto aqui será feita apenas uma breve introdução de sua 
sintaxe, para permitir o correto funcionamento da aplicação em questão.
Para declarar uma chamada à outra atividade do mesmo aplicativo, 
usa-se o seguinte fragmento de código: 
Intent a = new Intent(this, Tela2.class);
startActivity(a); 
Nesse fragmento, pode-se verificar, na primeira linha, a declaração 
de um objeto Intent “a”, que define uma intenção de iniciar uma nova 
atividade, chamada Tela2.class. e, na segunda linha, a utilização do 
comando startActivity indicando como parâmetro a intenção de chamada. 
Como foi visto no princípio deste tópico, o comando startActivity inicia 
uma atividade e não espera retorno algum dela. 
Introdução ao Coding Mobile
28
Evento de chamada 
Normalmente, a chamada a outra atividade ocorre como 
consequência de um evento realizado pelo usuário, como clicar em um 
botão ou qualquer outra interação do usuário com o layout, definida pelo 
programador. Desta forma, a simples implementação do código mostrado 
no item acima (Intent) não vai iniciar nenhuma nova atividade, pois não foi 
definido o evento que dispara esta ação. 
Apesar de o assunto layout ser tratado mais adiante neste material, 
segue abaixo o fragmento de código que mostra como inserir um botão e 
permitir que ele “escute” e reaja, executando a chamada desejada: 
Button b = new Button(this); 
b.setText = “ok”; 
As duas linhas de código acima declaram um objeto do tipo Button 
(botão) e definem “ok” como sendo o texto que deve aparecer no botão. 
Porém, a aplicação precisa saber que este botão deve ser “ouvido” quando 
for clicado, para executar alguma nova tarefa. Desta forma, insere-se a 
seguinte linha de código ao fragmento acima:
b.setOnClickListener(this);
Com essa linha adicionada ao código, quando o botão for clicado, o 
método onClick será chamado e dentro dele pode-se declarar a intenção 
(Intent) de chamar a nova tela. Toda vez que se permite que um botão 
reaja a um clique, deve-se implementar o método onClick para definir 
o que ele deve fazer quando for clicado. Desta forma, dentro da própria 
atividade, deve-se criar um método onClick, da seguinte forma:
public void onClick(View v) {
Intent i = new Intent(this, Tela2.class); 
startActivity(i); 
}
Introdução ao Coding Mobile
29
Modificando o código do exemplo anterior (App2_U3) para incluir 
um botão na atividade principal (MainActivity) que chame a atividade 
2 (tela2), conforme explicado acima. O botão deve ter como rótulo o 
texto: “Clique Aqui”. Neste exemplo modificaremos também o código da 
segunda atividade (Tela2) para que apresente a seguinte mensagem na 
caixa de texto: “Esta é a segunda tela da aplicação”. O código completo 
da atividade da Tela Principal do aplicativo deve ficar da seguinte maneira:
Figura 20 - Código para o exemplo acima
Fonte: app Android (2018)
Veja que foi necessário inserir várias linhas e modificar algumas 
outras. Não se preocupe em entender tudo isso agora. Este exemplo foi 
apenas para você entender as bases da funcionalidade de apps Android.
Perceba também que na linha 21, da figura acima, o método 
startActivity é utilizado para chamar a atividade 2 (tela2) da aplicação. Ela 
foi utilizada por que a tela principal não precisa, neste caso, de retorno.
Se você salvar e executar, o AVD deve ser parecer com o mostrado 
na figura abaixo:
Introdução ao Coding Mobile
30
Figura 21 – Resultado do exemplo acima
Fonte: app Android (2018)
Note que, ao abrir, a tela principal mostra o botão que preenche 
todo o espaço definido no layout. Clicando sobre o botão, a segunda 
tela é apresentada (toda em branco). Conforme já estudamos, logo que a 
segunda tela é aberta, primeira tela é parada temporariamente (pause) e 
fica em segundo plano. Neste momento, ambas as telas ocupam espaço na 
memória e recursos do dispositivo. Pressionando a tecla voltar, destacada 
com um quadrado vermelho, na figura acima, e a segunda tela é parada 
temporariamente (pause), parada definitivamente (stop) e, por fim, destruída 
(destroy), e a primeira tela volta para o primeiro plano (resume). 
Neste momento, apenas a tela principal ocupa espaço na memória 
e nos recursos do dispositivo. Pressionando mais uma vez a mesma 
tecla “Voltar”, a primeira tela é parada temporariamente (pause), parada 
definitivamente (stop) e, por fim, destruída (destroy), liberando toda a 
memória utilizada para a aplicação.
Você pode estar a pensar: “Um botão que ocupa todo o espaço da 
tela não adianta muita coisa. Seria interessante colocar mais componentes 
numa mesma tela!” 
- Perfeito! Você tem toda a razão! Logo aprenderemos como fazer 
isso! Um passo de cada vez! No próximo tópico veremos como fazer uma 
tela “conversar” com a outra por meio de parâmetros e logo em breve, 
veremos como manipular layouts. Sigamos em frente!
Introdução ao Coding Mobile
31
Passagem de parâmetros entre telas
A passagem de parâmetros estudada neste tópico não cria vínculo 
entre as telas. O foco é passar um ou mais parâmetros para a próxima 
tela e não o retorno de parâmetros, por isso o método utilizado ainda 
será o startActivity, não o startActivityForResult. Para passar parâmetros 
entre telas, é necessário utilizar o objeto Bundle (android.os.Bundle). A 
palavra bundle pode ser traduzida como “pacote” ou “embrulho”, e essa 
é exatamente a sua função, isto é, servir um embrulho ou pacote que 
contém os dados que precisam ser passados de uma atividade para outra. 
Para definir um objeto do tipo Bundle, utiliza-se a seguinte sintaxe:
Bundle <nome do pacote> = new Bundle;
Um exemplo seria:
Bundle pacote_de_dados = new Bundle;
Porém, é necessário definir o conteúdo desse “pacote de dados” 
e, para tanto, precisa-se utilizar o comando putString, da seguinte forma:
pacote_de_dados.putString(“msg”, “Olá”);
Na linha de código anterior, um dado do tipo string chamado “msg” 
e de conteúdo “Olá” está sendo adicionado ao “pacote de dados”. Podem 
ser adicionados vários dados a um mesmo “pacote de dados”. Porém, uma 
vez que o seu conteúdo esteja definido, é necessário incorporá-lo em uma 
intenção de chamada, pois ele de nada vale se não for passado adiante. 
Dessa forma, utiliza-se o método putExtras para incorporar o “pacote de 
dados” a uma Intent, da seguinte forma:
i.putExtras(pacote_de_dados); startActivity(i);
Introdução ao Coding Mobile
32
O código completo fica assim:
… 
{
//declara a intenção “i” para chamar outra tela (activity)
Intent i = new Intent(this, tela2.class);
//declara um pacote de dados que deve ser enviadopara a tela a 
ser chamada
Bundle pacote_de_dados = new Bundle();
//determina que o conteúdo do pacote de dados é um dados cha-
mado “msg” //cujo conteúdo é “Olá”.
pacote_de_dados.putString(“msg”, “Olá”);
//insere o pacote de dados na intenção de chamada “i”
i.putExtras(pacote_de_dados);
//chama a nova atividade, definida pela intenção “i”.
startActivity(i); 
}
Muito legal, não é? Agora você já sabe como passar parâmetros 
para uma nova tela. Mas isso é só o começo! Acompanhe o exemplo 
abaixo para esclarecer melhor como funciona todo o processo.
Crie um novo projeto de app, chamado App3_U3. A Activity principal 
deve ser do tipo “Empty Activity”, com o nome de Principal. Depois de 
aberto, o código da tela principal (classe Principal.java) do seu projeto 
deve se parecer com o mostrado na figura abaixo:
Figura 22 – App3_U3 – Código da classe Principal.java
Fonte: app Android (2018)
Introdução ao Coding Mobile
33
A primeira coisa a fazer é alterar o código acima para que o mesmo 
fique idêntico ao apresentado na figura 20. Pode-se destacar que, na figura 
22, foram destacados em vermelho os “imports” de bibliotecas e o método 
onCreate, para que você perceba claramente as alterações necessárias. A 
figura abaixo mostra o código da figura 22 com as alterações necessárias 
para ficar igual ao código da figura 20. Atenção para as modificações 
destacadas em vermelho.
Figura 23 - App3_U3 – Código da classe Principal.java
Fonte: app Android (2018)
Muito bem. O próximo passo é inserir as modificações referentes à 
passagem de parâmetros entre telas. O nosso código fica assim:
Figura 24 - App3_U3 – Código da classe Principal.java
Fonte: app Android (2018)
Introdução ao Coding Mobile
34
Em vermelho estão destacadas as linhas que foram alteradas ou 
incluídas.
Explicando o código: Ao ser iniciado, o aplicativo deve executar a 
função onCreate, na linha 14, como já foi explicado no ciclo de vida das 
Apps Android. Dentro deste método onCreate um botão “b” é criado e para 
ele é definido o texto “Clique Aqui” (linha 15). Na linha 16 é definido que 
este botão deve “escutar” uma ação de click, isto é, a partir da execução 
desta linha de código, o botão “b” deve reagir, a chamar o método onClick, 
quando for clicado.
Em sendo chamado, o método onclick executa as seguintes 
atividades: (repetimos o código para que você perceba e visualize todas 
as etapas).
//declara a intenção “i” para chamar outra tela (activity)
Intent i = new Intent(this, tela2.class);
//declara um pacote de dados que deve ser enviado para a tela a 
ser chamada
Bundle pacote_de_dados = new Bundle();
//determina que o conteúdo do pacote de dados é um dado cha-
mado “msg”,
cujo conteúdo é “Olá”.
pacote_de_dados.putString(“msg”, “Olá”);
//insere o pacote de dados na intenção de chamada “i”
i.putExtras(pacote_de_dados);
//chama a nova atividade, definida pela intenção “i”.
startActivity(i);
Você deve ter percebido que, depois de toda esta explicação, ainda 
não existe a tela2, necessária para o correto funcionamento do código 
acima.
Então, não seja por isso! Vamos inserir uma nova tela (activity) 
chamada de tela 2. Ela deve ter o seguinte código:
Introdução ao Coding Mobile
35
Figura 25 - App3_U3 – Código da classe Tela2.java
Fonte: app Android (2018)
Explicando o Código da figura 25:
Ao ser criada, a tela2 deve executar o código que está definido 
dentro do método onCreate, como você já sabe. Na linha 13 deste código 
é definido uma caixa de texto (TextView), de nome txt. Na linha 14 é definida 
uma variável, de nome “msg_recebida” e à ela é atribuído o conteúdo 
vazio. Na linha 15 é definido um objeto Intent que, neste caso, serve para 
capturar a intenção de chamada realizada pela tela principal. Na linha 16 
faz-se a verificação se a intenção de chamada capturada não está vazia 
(nula). Caso não seja nula, é executada a linha 18, que captura um suposto 
pacote, enviado pela tela principal, nesta intenção de chamada. 
Perceba que o pacote pode estar vazio, isto é, a intenção de chamada 
pode existir, mas não necessita de possuir parâmetros. Esta verificação é 
feita na linha 19 e, caso exista algum pacote de dados embutido nesta 
intenção de chamada, o mesmo é capturado na linha 21.
Introdução ao Coding Mobile
36
Por fim, a linha 24 define o conteúdo para a caixa de texto “txt” 
definida no início do código e, na linha 25, o layout, composto por esta 
caixa de texto, é apresentado na tela do dispositivo.
Salve e execute o código. O resultado é apresentado na figura abaixo:
Figura 26 – Resultado do exemplo – Passagem de parâmetros entre telas
Fonte: app Android (2018)
Que tal? Espero que esteja a perceber como tudo (conceitos 
e códigos) estudados nas unidades 1 e 2 desta disciplina estão a ser 
aplicados nesta unidade.
Vamos em frente!
Introdução ao Coding Mobile
37
Inserindo componentes na tela 
O Android Studio permite trabalhar com uma grande variedade de 
componentes. Neste material apresentaremos os mais comuns.
Conforme visto anteriormente, a estrutura dos projetos Android 
separa o layout (interface com o usuário) do código responsável pela ação, 
reação e regras de negócio tratadas pela tela, sendo o primeiro definido 
em um arquivo xml e o último em uma classe Activity (em linguagem Java).
Para melhor entendimento deste módulo, vamos criar um novo 
projeto no Android Studio. Isso você já sabe fazer, mas, para sedimentar 
o conhecimento, vamos apresentar todos os passos em detalhes, como 
mostrado a seguir:
1. Abra Android Studio e crie uma nova Aplicação Android;
2. Defina o nome da App como “App4_U3”;
3. Selecione o dispositivo Phone and Tablet e a API15: Android 4.0.3 
IceCreamSandwich;
4. Escolha uma “Empty Activity”, exatamente como foi feito nos 
exemplos anteriores e dê o nome de Principal. 
5. Depois do projeto estar carregado, clique em executar (Run), 
selecione o AVD para exibir a app e o resultado deve ser como 
mostrado na figura abaixo:
Figura 27 – AVD do exemplo.
Fonte: app Android (2018)
Introdução ao Coding Mobile
38
Até aqui, imagino que você já saiba fazer. Vamos, então, aprofundar 
nosso conhecimento.
Entendendo o Editor de Layout
Neste ponto é necessário explicar como funciona o editor de layout 
disponibilizado pelo Android Studio, bem como verificar como cada 
alteração de layout numa Activity (tela da app) impacta no código xml 
correspondente. Sendo assim, selecione o arquivo xml referente ao layout 
da nossa aplicação, clicando em app -> res -> layout, e selecionando o 
arquivo activity_principal.xml, como mostrado na figura abaixo:
Figura 28 – Selecionando o arquivo xml de layout da tela do dispositivo.
Fonte: app Android (2018)
Ao selecionar o arquivo de layout, conforme mostrado na figura 
acima, o Android Studio apresenta o Editor de Layout. Este editor 
permite que você crie o layout desejado cada uma das telas de sua 
aplicação, clicando e arrastando elementos para um “preview” de tela 
do AVD escolhido. O Editor de Layout deve do nosso app é mostrado na 
figura abaixo.
Introdução ao Coding Mobile
39
Figura 29 – Editor de Layout do app
Fonte: app Android (2018)
Na parte superior, da figura acima, está destacado em vermelho o 
AVD, a API e o tema que estaremos a utilizar neste projeto. É bem possível 
que o tema do seu projeto ainda não esteja definido como na figura 29, 
por isso, clique sobre o tema e selecione para ficar igual ao apresentado 
na referida figura, pois assim, os resultados apresentados neste material 
serão os mesmos que você obterá no seu computador.
Ao clicar no tema, uma tela de seleção será apresentada e, então, 
selecione o tema “Light”, como mostrado na figura abaixo.
Figura 30 – Seleção de tema para a app
Fonte: app Android (2018)
Introdução ao Coding Mobile
40
No canto inferior esquerdo da figura 29, há duas abas em destaque. 
A primeira (Design), que está a ser exibida na referida figura, mostra 
o editorde layout, enquanto a segunda (Text), mostra o arquivo xml 
correspondente ao layout. Ao clicar na aba “Text”, você terá uma visão do 
arquivo xml, conforme mostrado na figura abaixo.
Figura 31 – Arquivo xml correspondente ao layout da tela do app
Fonte: app Android (2018)
Como foi comentado anteriormente neste material, cada tela 
(activity) possui um arquivo xml de layout. Note que o elemento “TextView”, 
que visualizamos na figura 29, com o conteúdo “Hello World”, aparece no 
arquivo xml (da linha 9 até a linha 16) e que o conteúdo do mesmo está 
definido na linha 12. Experimente trocar o conteúdo deste elemento para 
“Tela Principal”, da seguinte maneira:
Android:text = “Tela Principal”
Depois de alterado, clique na aba Design e veja o que acontece. O 
resultado deve ser como mostrado na figura abaixo:
Figura 32 – Apresentação do layout do app
Fonte: app Android (2018)
Introdução ao Coding Mobile
41
Perceba também que o conteúdo do atributo “text”, destacado em 
vermelho, do lado direito da figura acima também foi alterado. Agora faça outro 
teste: Altere o conteúdo da caixa de texto (destacada em vermelho) para “Tela 
Principal da App” e pressione a tecla ENTER. Este ato terá duas consequências: 
(1) o conteúdo do elemento “TextView”, destacado em vermelho, no lado 
esquerdo da figura 32, que está posicionado no meio da tela do AVD será 
alterado e, clicando na aba “Text” você perceberá que o arquivo xml também 
foi alterado na linha 12, conforme mostrado na figura abaixo:
Figura 33 – Elemento TextView
Fonte: app Android (2018)
A conclusão é óbvia, mas precisa ser destacada aqui: Qualquer 
alteração no arquivo xml causa alterações no layout do app ou em algum 
atributo de um dos componentes da tela do app. E qualquer alteração no 
layout do app ou em qualquer atributo dos elementos que compõem a 
tela do app causa alterações no arquivo xml.
Você deve ter percebido que o Editor de Layout do Android Studio pode 
fazer muito mais do que apresentamos até agora. Não se preocupe. Vamos 
passo a passo, aprofundando-nos no decorrer desta Unidade e da próxima.
Uma vez que você já percebeu um pouco do Editor de Layout e sua 
relação com o arquivo xml, vamos em frente para entender como inserir 
componentes na tela do app.
Primeiro, precisamos mudar o layout da tela. Se olharmos com 
atenção na figura 31 – linha 2 – perceberemos que o layout definido 
até o momento para o nosso app é o ConstraintLayout. Vamos mudar 
esta especificação para um tipo de layout mais simples e de mais fácil 
entendimento neste momento: LinearLayout. Para isso, clique na aba 
“Design” e verifique a janela chamada “Componente Tree” ou, em português: 
Árvore de Componentes”. Ela deve mostrar todos os componentes ou 
Introdução ao Coding Mobile
42
elementos que estão presentes na tela da sua app até o momento e deve 
estar como mostrado na figura abaixo.
Figura 34 – Árvore de componentes do app
Fonte: app Android (2018)
Clique com o botão direito do mouse sobre o referido layout e 
selecione o item “Convert View...” e uma tela com os layouts disponíveis 
será apresentada. Nesta nova tela, selecione o “LinearLayout” e clique no 
botão “Apply”, como mostrado na figura a seguir:
Figura 35 – Alterando o Layout da tela da app
Fonte: app Android (2018)
A janela que apresenta a “Árvore de Componentes” deve ser 
alterada para informar que o layout para a app passou a ser definido 
como LinearLayout (horizontal). Porém, queremos que a orientação 
dos componentes seja vertical, por isso, clique uma vez, com o botão 
esquerdo do mouse sobre o referido layout e altere o atributo orientação, 
como destacado em vermelho na figura abaixo:
Figura 36 – Alterando a orientação do layout para “vertical”
Fonte: app Android (2018)
Introdução ao Coding Mobile
43
Se você clicar na aba “Text”, verá seguinte código xml:
Figura 37 – Arquivo xml da tela da app depois de ter o layout definido para LinearLayout
Fonte: app Android (2018)
IMPORTANTE:
Os tipos de layout e suas características serão vistos mais 
adiante neste material, então, por agora, estamos apenas a 
introduzir o assunto. 
Perceba a diferença deste arquivo (figura 37) para o arquivo xml da 
figura 31. 
Agora que o layout da tela está devidamente configurado, 
precisamos aprender a inserir componentes na nossa app.
TextView
O componente TextView é um rótulo ou uma etiqueta (label) onde 
podemos escrever um texto que pode ser lido, mas não pode ser alterado 
pelo usuário do app. 
Neste subtópico iremos, primeiramente, deletar o componente 
Textview que já existe (apenas para praticar) e adicionar um novo. 
Para deletar o componente TextView (ou qualquer outro que você 
deseje): (1) clique na aba “Design” para visualizar o Editor de Layout do 
Introdução ao Coding Mobile
44
AVD; (2) clique sobre o componente TextView, cujo texto é “Tela principal 
da App” e pressione a tecla “delete” em seu teclado.
Para inserir o novo componente TextView: Selecione, na janela 
“Palette” (que fica acima da janela “Component Tree”) o componente Text 
-> TextView, conforme destacado em vermelho na figura abaixo:
Figura 38 – Janela Palette
Fonte: app Android (2018)
Clique e arraste o componente para a tela do AVD. Note que, ao soltar 
o componente sobre a tela do AVD, ele se adequa ao tamanho da tela e fica 
posicionado na parte superior da mesma, como mostra a figura abaixo:
Figura 39 – TextView inserido na tela do AVD
Fonte: app Android (2018)
Repare que, se você clicar sobre o componente TextView Inserido, 
aparecerá, do lado direito da tela, destacado com retângulo vermelho 
uma janela com as propriedades (atributos) deste componente.
Introdução ao Coding Mobile
45
Podemos identificar claramente que o componente possui um 
identificador único, chamado ID, cujo valor é TextView2. Possui também 
duas propriedades parecidas, chamadas de layout_width e layout_height, 
as quais definem as propriedades de largura e altura do componente, 
respectivamente. Para cada uma destas duas propriedades, podemos ter 
3 valores diferentes, a saber: (1) match_parent: que define que o objeto 
deve ter a mesma largura (width) e/ou altura (height) do componente 
no qual ele está contido. Para este caso em específico, sabemos que 
o componente TextView está contido no componente LinearLayout. 
Podemos provar isso ao analisar a janela “Component Tree” que destaca 
claramente esta característica. (2) outro valor possível é wrap_content. 
Se este valor for escolhido para esta propriedade, a largura (width) e/
ou altura (height) do componente TextView será ajustado ao tamanho 
do texto que ele possui. Importante destacar que se o componente não 
tiver valor para a propriedade texto, isto é, se a propriedade “text” estiver 
vazia, o componente ficará invisível. (3) podemos clicar nos três pontos “...” 
que estão à direita da ca caixa de combinação e selecionar um dos itens 
apresentados numa tela especial.
Logo depois destas propriedades, existe uma propriedade chamada 
“text” que define o texto que o componente TextView irá apresentar na tela 
do AVD. Defina para esta propriedade o seguinte valor: “Bem vindo ao meu 
app. Digite seu nome e clique em OK para entrar.” e pressione ENTER. 
O texto que você acabou de digitar aparecerá em uma única linha 
no AVD, mas você pode clicar sobre o componente e alterar a largura ou 
altura do mesmo, para ficar parecido com a figura abaixo:
Figura 40 – Componente TextView no Editor de Layout
Fonte: app Android (2018)
Introdução ao Coding Mobile
46
Salve e execute o aplicativo. O resultado deve ser como mostrado 
na figura abaixo:
Figura 41 – Componente TextView com o aplicativo em execução
Fonte: app Android (2018)
Note que você pode alterar outras propriedades do componente 
TextView, tais como tipo, cor e tamanho da fonte, entre outras, como 
mostra a figura abaixo:
Figura 42 – Propriedades do componente TextView
Fonte: app Android (2018)
Introduçãoao Coding Mobile
47
Muito bem. A frase que aparece no componente TextView nos dá 
uma deixa para aprendermos inserir dois novos componentes: o Plain Text 
e o Button. Então vamos lá!
Pain Text
O Plain Text é uma caixa de texto que permita ao usuário digitar algo. 
Ele tem os mesmos atributos que o componente TextView e mais um, 
chamado de Input Type, que define o tipo de dado que este componente 
vai receber. Podemos definir o conteúdo da propriedade “text” como vazio, 
afinal, o usuário vai digitar o seu nome ali.
Para incluir este componente, siga o mesmo método que usou para 
inserir o componente TextView. Salve e execute o app. A tela do AVD deve 
ficar assim:
Figura 43 – AVD com TextView e Plain Text
Fonte: app Android (2018)
Note que: (1) o atributo android:text (no arquivo xml correspondente) 
foi definido como “” (vazio). Isso faz sentido, pois o objetivo desse 
componente é receber um texto e não o apresentar. Mas você pode 
alterar esta propriedade para dar uma dica ao usuário, caso você queira. 
(2) Este componente, chamado android:inputtype, responsável por definir 
Introdução ao Coding Mobile
48
o tipo de dado que o componente irá receber. Pode conter valores como 
text, date, time, datetime, numberDecimal, number e textPassword, entre 
outros. (3) Você também pode alterar outras propriedades, conforme 
mostrado na figura abaixo:
Figura 44 – Propriedades do componente PlainText
Fonte: app Android (2018)
Introdução ao Coding Mobile
49
Button
Agora precisamos inserir um botão com o texto “OK”. Para isso, 
selecione o item Button -> Button, na janela Palette, como mostrado na 
figura abaixo.
Figura 45 – Inserindo um Botão
Fonte: app Android (2018)
Insira o botão na tela, altere seu tamanho e troque o valor de sua 
propriedade “text” de “Button” para “OK”.
Ao salvar e executar, o app deve ficar mais ou menos assim:
Figura 46 – AVD com TextView, Plain Text e Button
Fonte: app Android (2018)
Antes de passarmos para o próximo componente, clique na 
aba “Text” e verifique o arquivo xml correspondente a esta activity que 
acabamos de fazer. Ela deve estar parecida com a figura abaixo:
Introdução ao Coding Mobile
50
Figura 47 – Arquivo xml correspondente ao AVD da figura 44
Fonte: app Android (2018)
Repare como cada componente está descrito no código xml: o 
layout e cada um dos componentes.
Radio button
Existem muitas opções de componentes, como você pode reparar 
na janela Palette, apresentada na figura abaixo:
Figura 48 – Janela Palette
Fonte: app Android (2018)
Introdução ao Coding Mobile
51
Mas, antes de inserir mais componentes, como o Radio Button, 
vamos criar outra Activity (tela) para a nossa app. Esta Activity deve ser 
chamada de “Tela2” e deve ser uma Empty Activity. Depois de criada a 
nova Activity, não esqueça de mudar o layout para LinearLayout (vertical), 
assim como fizemos com a Activity Principal.
Isto posto e realizado, podemos inserir o radio button. Para tanto, 
selecione o item Buttons e perceba que existem dois componentes que 
inicial com o nome Radio: RadioGroup e RadioButton. Primeiro selecione o 
RadioGroup e arraste para a tela do AVD. Depois selecione 3 componentes 
RadioButton e arraste para o interior do RadioGroup que você acabou de 
inserir. Seu projeto deve ficar como mostrado na figura abaixo:
Figura 49 – Inserindo Radio Buttons na Activity
Fonte: app Android (2018)
Para melhorar o layout desta activity, selecione o componente 
RadioGroup, defina ambos os valores das propriedades layout_width e 
layout_height para para “wrap_content”. Sua tela deve ficar assim:
Introdução ao Coding Mobile
52
Figura 50 – Melhorando o layout da figura 46
Fonte: app Android (2018)
Repare que todos os componentes RadioButtons tem o mesmo 
valor para a propriedade “text”. Clique no primeiro e defina esta propriedade 
para “Aluno”, defina para o segundo o valor “Professor” e para o terceiro o 
valor “Outro”. Sua tela deve ficar assim:
Figura 51 – Projetando a Activity 2 da app.
Fonte: app Android (2018)
Vamos inserir agora um TextView com o seguinte texto: “Qual é 
sua posição nesta instituição?” Podemos imaginar que este app seja 
direcionado para uma determinada instituição de ensino.
Clique e arraste o componente TextView de maneira que ele fique 
acima do RadioGroup. A tela deve ficar assim:
Introdução ao Coding Mobile
53
Figura 52 – Projetando a Activity 2 da app.
Fonte: app Android (2018)
Não esqueça que você pode alterar outras propriedades, tais como 
espaçamento, cor, tipo e tamanho de fonte, entre outras, em todos os 
componentes.
Check box e Combo box
Para inserir estes componentes, use os mesmos recursos aprendidos 
até o momento. Sua tela deve ficar como mostrado na figura abaixo
Figura 53 – Projetando a Activity 2 da app.
Fonte: app Android (2018)
Introdução ao Coding Mobile
54
Bom, você já deve ter percebido a quantidade de componentes 
que pode utilizar para montar uma app. Então, use sua imaginação, monte 
um aplicativo ao seu estilo! 
Alterando as propriedades de cada componente você pode criar 
um app mais amigável e legível. Use sua imaginação!
Figura 54 – Alterando propriedades de cada elemento da tela.
Fonte: app Android (2018)
No caso do elemento ComboBox, ele está definido como Container 
->”Spinner” na janela Palette, como mostrado na figura abaixo:
Figura 55 – Componente ComboBox
Fonte: app Android (2018)
Introdução ao Coding Mobile
55
Outro aspecto importante: Para definir seu conteúdo é necessário 
criar um Array de opções no arquivo strings.xml, dentro da pasta values. 
Sua localização é mostrada na figura a seguir:
Figura 56 – Localização do arquivo string.xml
Fonte: app Android (2018)
Neste caso, precisamos inserir um array com os valores “masculino” 
e “feminino” dentro deste arquivo. Para tanto clique sobre este arquivo 
digite o seguinte código:
Figura 57 – Arquivo string.xml
Fonte: app Android (2018)
Note que o que você precisa digitar este destacado em vermelho. O 
que está em azul é outro exemplo para você perceber como o processo 
segue o mesmo padrão.
Introdução ao Coding Mobile
56
Uma vez que você tenha digitado o código do arquivo xml, conforme 
apresentado na figura acima, volte para o Editor de Layout da tela 2 e 
clique no componente combobox (spinner) e verifique suas propriedades.
Uma delas será a “entries”. Clique no botão ao lado desta 
propriedade, e você verá mais ou menos como mostra a figura abaixo:
Figura 58 – Criando valores para o componente ComboBox
Fonte: app Android (2018)
Em destaque vermelho, na figura acima, podemos verificar que ao 
clicar no link da propriedade “entries”, a tela “Resources” é apresentada.
Do lado esquerdo, selecione a opção “Array”, destacado em azul e 
você terá acesso a todos os arrays definidos no arquivo string.xml, dentre 
os quais aparece o array que trata sobre o “estado civil” e outro que trata 
sobre “sexo”. Clique duas vezes sobre o array que fornece as opções de 
“sexo” e a tela será fechada.
Finalmente, para testar se tudo está a funcionar, salve o seu projeto 
e execute-o. Note que apenas a primeira tela (Principal) aparece e, 
aparentemente não temos como acessar a tela 2 para verificar os demais 
componentes.
Existem duas soluções possíveis: (1) você fazer o mesmo processo que 
fizemos no módulo 2 desta unidade ou você pode fazer a seguinte alteração:
a. Abra o arquivo AndroidManifest.xml. Ele deve se parecer como o 
mostrado abaixo:
Introdução ao Coding Mobile
57
Figura 59 – Arquivo AndroidManifest.xml
Fonte: app Android (2018)
Note que, destacado em vermelho estão os comandos que 
permitem ao AndroidStudio saber qual das telas deve ser a primeira a ser 
aberta quando o aplicativo for executado.
b. Faça uma alteração neste código para que o <intent-filter>, que 
estudamos na primeira Unidade desta disciplina, passe da tela 
Principal para a tela2, da seguinte maneira:
Figura 60 – Alterando a tela inicialdo aplicativo
Fonte: app Android (2018)
Introdução ao Coding Mobile
58
Salve o arquivo e execute a aplicação. Você verá que a tela2 será 
apresentada e deve se parecer com a figura abaixo:
Figura 61 – Tela 2 da aplicação
Fonte: app Android (2018)
Bem, decerto que já vimos muita coisa. Não esqueça de testar, criar, 
inventar, modificar as propriedades e verificar seus efeitos.
Na próxima unidade veremos como tratar os eventos gerados por 
cada um dos componentes vistos nesta unidade. Não se esqueça de se 
aprofundar nos conhecimentos, acessando as referências apresentadas. 
Abraço e até a próxima Unidade desta disciplina.
Introdução ao Coding Mobile
59
REFERÊNCIAS
CLARO, D.; SOBRAL, J. Programação em JAVA. Florianópolis: 
Copyleft Pearson Education, 2008. 89 p. Disponivel em: <http://www.
faeterj-rio.edu.br/downloads/bbv/0031.pdf>. Acesso em: 06 Set. 2018.
CORDEIRO, F. Android Studio. 3. ed. [S.l.]: AndroidPro, 2016.
CORDEIRO, F. Android Aprendiz. [S.l.]: AndroidPro, 2017. 37 p. 
Disponivel em: <https://www.androidpro.com.br/>. e-Book.
DALL’OGLIO, P. PHP - Programando com Orientação a Objetos. 3. 
ed. SP: Novatec Editora, 2016. ISBN 978-85-7522-465-6. Acesso em: 30 
Ago. 2018.
DEITEL, H. M.; DEITEI, P. J. Java, como programar. 4. ed. Porto Alegre: 
Bookman, 2003.
GOSLING, J.; MCGILTON, H. The Java Language Environment. 
Mountain View,: Sun Microsystems, Inc, 1995.
MATTOS, E. Programação de softwares em Java. SP: Digerati Books, 
2007.
MEIRELLES, A. Smartphones, Guia Prático - Android. Hardware.
com.br, 2009. Disponivel em: <https://www.hardware.com.br/livros/
smartphones/android.html>. Acesso em: 05 Set. 2018.
ORACLE.COM. Java Documentation. Oracle, 2018. Disponivel em: 
<https://docs.oracle.com/javase/tutorial/getStarted/intro/definition.
html>. Acesso em: 13 Set. 2018.
SINGH, C. @Override annotation in Java. JAVA TUTORIAL, 2017. 
Disponivel em: <https://beginnersbook.com/2014/07/override-
annotation-in-java/>. Acesso em: 03 Out. 2018.
Introdução ao Coding Mobile
	Ciclo de vida do aplicativo Android e a Classe Activity 
	Introdução
	Gerenciando aplicativos
	Ciclo de vida do aplicativo Android
	A Classe Activity
	Navegabilidade
	Introdução
	Chamando a segunda Activity
	Intenção de chamada
	Evento de chamada 
	Passagem de parâmetros entre telas
	Inserindo componentes na tela 
	Entendendo o Editor de Layout
	TextView
	Pain Text
	Button
	Radio button
	Check box e Combo box