_Ebook da Unidade - Front End e Conexão Com o Back End

Prévia do material em texto

PROGRAMAÇÃO 
CODING (MOBILE)
Unidade 3
Gerenciando o APP 
android
CEO 
DAVID LIRA STEPHEN BARROS
Diretora Editorial 
ALESSANDRA FERREIRA
Gerente Editorial 
LAURA KRISTINA FRANCO DOS SANTOS
Projeto Gráfico 
TIAGO DA ROCHA
Autoria 
LUIZ FERNANDO CORCINI
4 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
A
U
TO
RI
A
Luiz Fernando Corcini
Olá. Sou graduado em Engenharia Eletrônica, especializado 
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 software 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 à á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ê nessa fase de muito estudo e trabalho. 
Conte comigo! 
5PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
ÍC
O
N
ES
Esses ícones aparecerão em sua trilha de aprendizagem nos seguintes casos:
OBJETIVO
No início do 
desenvolvimento 
de uma nova 
competência. DEFINIÇÃO
Caso haja a 
necessidade de 
apresentar um novo 
conceito.
NOTA
Quando são 
necessárias 
observações ou 
complementações. IMPORTANTE
Se as observações 
escritas tiverem que 
ser priorizadas.
EXPLICANDO 
MELHOR
Se algo precisar ser 
melhor explicado ou 
detalhado. VOCÊ SABIA?
Se existirem 
curiosidades e 
indagações lúdicas 
sobre o tema em 
estudo.
SAIBA MAIS
Existência de 
textos, referências 
bibliográficas e links 
para aprofundar seu 
conhecimento.
ACESSE
Se for preciso acessar 
sites para fazer 
downloads, assistir 
vídeos, ler textos ou 
ouvir podcasts. 
REFLITA
Se houver a 
necessidade de 
chamar a atenção 
sobre algo a 
ser refletido ou 
discutido.
RESUMINDO
Quando for preciso 
fazer um resumo 
cumulativo das últimas 
abordagens.
ATIVIDADES
Quando alguma 
atividade de 
autoaprendizagem 
for aplicada. TESTANDO
Quando uma 
competência é 
concluída e questões 
são explicadas.
6 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
SU
M
Á
RI
O
Ciclo de vida do aplicativo Android e classe Activity ............... 9
Introdução ............................................................................................................. 9
Gerenciando aplicativos ...................................................................................11
Ciclo de vida do aplicativo Android ................................................................11
A classe Activity ...................................................................................................14
Navegabilidade ........................................................................ 24
Introdução ...........................................................................................................24
Chamando a segunda Activity ..........................................................................30
Intenção de chamada .........................................................................30
Evento de chamada ............................................................................31
Passagem de parâmetros entre telas.................................... 36
Entendendo a passagem de parâmetros entre as telas ........................... 36
Inserindo componentes na tela ............................................. 46
Entendendo o leitor de layout .........................................................................47
TextView ................................................................................................................56
Plain Text ..............................................................................................................62
Button ...................................................................................................................63
Radio Button .......................................................................................................65
Check Box e Combo Box .....................................................................................69
7PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
A
PR
ES
EN
TA
ÇÃ
O
Seja bem-vindo à Unidade 3 da disciplina de Programação 
Coding Mobile. Nesta unidade, usaremos os conhecimentos 
adquiridos anteriormente e aprenderemos a criar e gerenciar uma 
aplicação básica em JavaAndroid.
O conteúdo está dividido em quatro módulos. No primeiro 
capítulo, você entenderá como funciona o ciclo de vida da aplicação 
mobile Android e como implementar uma classe Activity. Em 
seguida, estudaremos a navegabilidade, isto é, como implementar 
uma aplicação Android com várias telas e como fazer uma tela 
chamar a outra. No terceiro capítulo, aprenderemos a passar 
parâmetros entre uma tela e outra da aplicação, construindo, 
assim, uma aplicação mais complexa e robusta. Finalmente, no 
capítulo 4, veremos como inserir alguns dos componentes básicos 
em uma aplicação Android para que ela fique mais interativa.
É claro que existe muito mais para aprender, mas o 
aprofundamento de cada um desses conhecimentos pode ser 
feito acessando os links indicados durante o texto, no tópico Saiba 
Mais.
Vamos começar? Excelente estudo para você!
8 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
O
BJ
ET
IV
O
S
Olá. Seja muito bem-vindo à Unidade 3. Nosso 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 a classe Activity.
2. Aplicar os recursos da linguagem Java para proporcionar 
a navegabilidade de aplicativos para dispositivos 
móveis, com base no Android.
3. Transmitir parâmetros entre as telas de um aplicativo 
desenvolvido na linguagem Java para dispositivos 
móveis Android.
4. Codificar e tratar eventos acionados pelo usuário e 
pela máquina em aplicativos Android, por meio da 
linguagem Java Mobile.
9PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Ciclo de vida do aplicativo 
Android e classe Activity
OBJETIVO
Ao término deste capítulo, você será capaz de en-
tender como acontece o ciclo de vida do aplicativo 
Android, bem como a classe Activity.
Agora que você já está com o ambiente de desen-
volvimento Java-Android instalado e configurado 
em seu computador, além de já ter certa familia-
ridade com a linguagem Java, podemos chegar ao 
entendimento de como funcionam os apps An-
droid. Vamos lá!
Introdução
A maioria das aplicações Android requer uma interface 
que possibilite a interação com o usuário, também conhecida 
como UI (User Interface). Essa interface pode ser composta por 
uma ou mais telas, nas quais elementos como botões, caixas de 
texto, figuras, animações, caixas de seleção, entre outros, são 
apresentados. É crucial ressaltar que cada atividade (classe Activity) 
representa uma única tela (UI) do aplicativo e é encarregada de 
gerenciar (tratar) os eventos que o usuário pode gerar em cada 
elemento apresentado, como clicar em um botão, digitar um texto 
ou selecionar um item.
No caso de aplicações que demandam mais de uma tela, 
é necessário implementar mais de uma atividade. Por exemplo, 
um aplicativo de e-mail deve ter uma atividade que exiba a lista 
de e-mails, outra dedicada a permitir que o usuário redija um 
novo e-mail e ainda outra para mostrar o conteúdo do e-mail, 
proporcionando ao usuário a leitura do mesmo.
10 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Apesar das atividades de uma mesma aplicação trabalha-
rem juntas para compor as funcionalidades de um aplicativo, elas 
são independentes umas das outras e podem ser iniciadas indivi-
dualmente caso a configuração do aplicativo permita.
Uma característicaespecial dos aplicativos Android é que 
uma aplicação pode iniciar qualquer componente instalado no 
aplicativo e utilizar seus recursos, se assim estiver configurado.
SAIBA MAIS
Uma nova aplicação pode necessitar da captura 
de uma foto utilizando o dispositivo de câmera. 
Para realizar esta tarefa, essa nova aplicação pode 
recorrer a um aplicativo já existente, evitando a 
necessidade de implementar essa funcionalidade 
por conta própria. Em outras palavras, ela pode 
utilizar os recursos de uma aplicação já existente 
sem precisar incorporá-la ou estar vinculada a 
ela de alguma maneira. Para alcançar isso, a nova 
aplicação apenas precisa ser capaz de iniciar a 
atividade de captura de foto da outra aplicação. 
Assim que a atividade de captura de foto for 
concluída, a imagem é retornada para a nova 
aplicação, onde pode ser tratada e utilizada de 
acordo com as necessidades do programador.
Um detalhe importante a considerarmos é 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 isso, ela manda uma mensagem ao sistema Android 
indicando a intenção de iniciar a outra atividade, o qual 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á estudada em detalhes mais adiante, bem como os processos 
de ativação de componentes.
11PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Gerenciando aplicativos
É importante entendermos 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. Assim, 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 em primeiro lugar no topo da pilha. Além disso, o 
aplicativo com status pause ou stop pode, a qualquer momento, ser 
descartado (encerrado) pelo sistema operacional para liberar mais 
memória, caso 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. Nesse contexto, o termo “criar” (create) não tem o 
sentido de “implementar” ou “desenvolver”, mas de “instanciar”, 
isto é, ser executado e passar a ocupar um espaço de memória, 
utilizando recursos do sistema.
12 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
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 interface vai ser utilizada e quais são os componentes dela. 
Para entrar em operação e poder ser utilizado, o aplicativo, depois 
de criado, precisa ser iniciado.
Quando isso acontece, o método onStart é chamado. 
Ele não é obrigatório, mas podemos 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 que seja 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 ao segundo lugar da pilha 
de aplicativos. Esse evento é capturado pelo método onPause, 
o qual 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 muito útil, pois, caso a 
aplicação volte ao topo da pilha, é necessário saber qual era sua 
situação e quais eram seus dados antes de ser temporariamente 
parado.
Para voltar a utilizar o aplicativo que está parado 
temporariamente, é preciso recolocá-lo no topo da pilha. 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), e o método que captura esse 
evento é o onStop.
Uma vez parado, o usuário só conseguirá utilizar 
novamente o aplicativo se reiniciá-lo. Se isso acontecer, o método 
13PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
onRestart será chamado, capturando, assim, o evento e passando 
o controle para o método onStart. Depois de parado, o aplicativo 
pode ser retirado da pilha, isto é, ser descartado. Quando isso 
acontece, o método onDestroy é chamado, e o ciclo de vida da 
aplicação termina.
Nessa perspectiva, para ter acesso a esse aplicativo depois 
de ele ter sido retirado da pilha, o usuário deve recriá-lo, fazendo 
com que outro ciclo de vida tenha início. Vejamos o diagrama de 
transição de estado a seguir, que representa esse ciclo.
Imagem 3.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: Elaborada pela autoria (2023).
Para entendermos melhor a imagem apresentada, 
podemos fazer uso da seguinte 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.
14 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
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 - nesse 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 fazem parte da classe 
Activity, a qual é utilizada pelo sistema operacional Android para 
ajudar a gerenciar o ciclo de vida dos aplicativos.
A seguir veremos mais detalhes sobre essa classe.
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. Assim, cada atividade é responsável por fornecer uma tela 
com a qual 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.
15PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
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:
Imagem 3.2 – Representação gráfica da classe Activity
CLASSE Activity
...
onCreate()
onStart()
onResume()
onPause()
onRestart()
onStop()
onDestroy()
...
Fonte: Elaborada pela autoria com base no app Android (2023).
Naturalmente, como não mencionamosos 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 esse 
motivo, após o método onDestroy, também foi colocado “...”.
EXEMPLO: é importante salientarmos que podem 
acontecer modificações à medida que são feitas as 
atualizações. Agora, considerando essa informação, abra 
o Android Studio e crie um novo projeto, clicando no item 
“Start a new Android Studio Project”, destacado na imagem 
a seguir.
16 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Imagem 3.3 – Criando um novo projeto Android
Fonte: Elaborada pela autoria (2023).
Em seguida, defina o nome da aplicação como App1_U3, 
a dizer que essa é nossa primeira aplicação criada na Unidade 3 
desta disciplina, conforme apresentado a seguir.
17PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Imagem 3.4 – Definindo o nome da aplicação
Fonte: Elaborada pela autoria (2023).
Deixe os demais campos como estão e clique em “Next”. 
Marque a opção “Phone and Tablet” e selecione a “API15”, 
como mostrado anteriormente e clique em “Next”.
IMPORTANTE
Caso você não se recorde do motivo pelo qual está 
fazendo essas seleções, reveja o material estudado 
nas outras unidades desta disciplina.
18 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
A tela a seguir deve aparecer.
Imagem 3.5 – Adicionando a Activity ao projeto
Fonte: Elaborada pela autoria (2023).
Selecione a “Empty Activity” e clique em “Next”. A tela a 
seguir deve ser apresentada.
Imagem 3.6 – Classe Activity do projeto
Fonte: Elaborada pela autoria (2023).
Com os conhecimentos que você adquiriu nas unidades 
anteriores sobre linguagem Java, você pode entender o código 
apresentado antes. Mesmo assim, vamos detalhá-lo a seguir.
19PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
 • A linha 1 define o pacote em que se encontra a classe 
Activity que estamos visualizando.
 • A linha 6 declara a classe MainActivity (Atividade 
principal), que vai gerenciar a tela principal de nosso 
aplicativo, pois, como vimos anteriormente, cada tela 
é gerenciada por uma classe Activity. É importante 
também verificarmos que a classe MainActivity herda 
(extends) características e comportamentos da classe 
AppCompatActivity.
 • Na linha 8, existe uma expressão informando que o 
método a seguir é uma sobrescrita. Assim, usamos @
Override toda vez que substituímos um método. Quanto 
a isso, conforme Singh (2017), seu uso fornece dois 
benefícios: 
1. Indicar, com certeza, que você realmente está 
substituindo o método que deseja. Caso você cometa 
um erro comum ao digitar incorretamente o nome 
de um método ou não corresponder exatamente aos 
parâmetros, você será avisado de que o método não 
está realizando a substituição da forma como você está 
pensando.
2. Tornar o seu código mais fácil de entender, porque é 
mais óbvio quando os métodos são sobrescritos.
 • A linha 9 mostra o método onCreate sendo declarado. 
Esse método 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á 
sendo criada.
20 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Verificando o conteúdo da classe MainActivity, descrita 
anteriormente, podemos perceber que apenas o método onCreate 
está sendo utilizado, pois somente ele é obrigatório. Como vimos, 
existem outros seis métodos que completam o ciclo de vida de 
uma aplicação, os quais podem ser utilizados para permitir 
ao programador maior controle sobre a aplicação que está 
desenvolvendo. Portanto, se você executar a aplicação, o resultado 
deve ser o mostrado na imagem a seguir.
Imagem 3.7 – AVD da execução do projeto
Fonte: Elaborada pela autoria (2023).
O exemplo a seguir apresenta o código que deve ser 
implementado em seu projeto (na classe MainActivity) para dar 
uma noção do funcionamento da atividade quando ela possui 
todos os métodos de controle do ciclo de vida da aplicação.
21PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Para tanto, implemente o seguinte código na sua classe 
MainActivity, apresentado na imagem a seguir:
Imagem 3.8 – Exemplo dos métodos de gerenciamento de aplicações de app Android
Fonte: Elaborada pela autoria (2023).
Esse código apresentado não tem função prática alguma, a 
não ser permitir que você entenda como funciona o gerenciamento 
do ciclo de vida de aplicativos Android.
22 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Agora salve e execute a aplicação. Para verificar o resultado, 
abra a janela chamada “Run”, como mostrado na imagem a seguir, 
e verifique os itens em destaque.
Imagem 3.9 – Resultado da execução do código do exemplo
Fonte: Elaborada pela autoria (2023).
O AVD deve estar como mostra a imagem a seguir:
Imagem 3.10 – AVD do exemplo
Fonte: Elaborada pela autoria (2023).
23PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Para verificar o resultado da execução dos métodos, clique 
em um dos botões em destaque na imagem anterior.
IMPORTANTE
Compare o resultado apresentado na janela “Run” 
com o diagrama de transição de estado (Imagem 
3.1).
RESUMINDO
E então? Gostou do que lhe mostramos? Aprendeu 
mesmo tudinho? Agora, só para termos certeza de 
que você realmente entendeu o tema de estudo 
deste capítulo, vamos resumir o que vimos.
Aqui, você conheceu o ciclo de vida do aplicativo 
Android, bem como a classe Activity. Espero que 
você tenha aprendido muitos conceitos novos 
enriquecedores ao seu conhecimento. Avante!
24 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Navegabilidade
OBJETIVO
Ao término deste capítulo, você será capaz de 
entender como funciona a navegabilidade do 
aplicativo Android. Então, animado com mais uma 
etapa de estudos? Vamos lá!
Introdução
Aplicativos mais complexos normalmente possuem mais 
de uma tela ou precisam chamar outros aplicativos para executar 
uma função especializada. Vamos aprender agora a criar novas 
telas (Activity) para um mesmo aplicativo, a navegar entre elas e 
também a permitir que a tela de um aplicativo (Activity) chame 
outro aplicativo (Activity). Nessa perspectiva, 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 de utilizar um desses dois métodos deve recair 
sobre a seguinte questão: a tela (Activity1) que está chamando a 
outra (Activity2) precisa de um retorno ou um vínculo para poder 
continuar suas atividades depois que a tela chamada (Activity2) for 
fechada?
Em caso de resposta positiva, devemos utilizar o método 
startActivityForResult. Mas, se esse não for o caso e a tela (Activity1) 
que está chamando a outra tela (Activity2) não precisar de vínculo 
ou retorno, devemos utilizar o método startActivity. Vejamos as 
imagens a seguir, que representam graficamente esses dois casos. 
25PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
 • Uso do método startActivity.
Imagem 3.11 – Activity1 não precisa de retorno da Activity2 depois que a última for fechada e 
o foco retornar para a primeira
Activity 2Activity 1
Tela simples com 
botão.
Fonte: Elaborada pela autoria (2023).
 • Uso do método startActivityForResult:
Imagem 3.12 – Activity1 precisa de retorno da Activity2 depois que a última for fechada e o 
foco retornar para a primeira
Activity 2Activity 1
Ligação telefônica
Fonte: Elaborada pela autoria (2023).
Para entendermos melhor algumas características 
necessárias à navegabilidade correta entre as telas de um 
aplicativo Android, vamos verificar o exemplo a seguir. Devemos 
criar 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çãodo menu “File-
>New -> New Project...”, como mostra a imagem a seguir.
26 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Imagem 3.13 – Criando o projeto App2_U3
Fonte: Elaborada pela autoria (2023).
Note que esse novo projeto, a exemplo do anterior, 
possui apenas uma Activity (tela), chamada de MainActivity, ou tela 
principal. Agora 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 
o app e selecione new->Activity->Empty Activity, conforme mostra a 
imagem a seguir.
27PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Imagem 3.14 – Inserindo uma nova Activity no projeto
Fonte: Elaborada pela autoria (2023).
Assim, o seu projeto deve ficar como mostra a imagem a 
seguir.
28 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Imagem 3.15 – Projeto com três Activities ou telas
Fonte: Elaborada pela autoria (2023).
Agora salve, execute o projeto e verifique se apenas a 
atividade principal fica visível e se as duas outras atividades (tela2 
e tela3) não estão acessíveis. Para verificar o porquê de isso 
acontecer, precisamos analisar o arquivo AndroidManifest.xml, 
cujo código é apresentado a seguir.
29PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Imagem 3.16 – Arquivo AndroidManifest.xml do projeto App2_U3
Fonte: Elaborada pela autoria (2023).
Repare que apenas a atividade principal (MainActivity), na 
linha 12, possui o . Esse 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; e (2) categoria (category), 
que define se o usuário pode iniciar a atividade diretamente a 
partir do menu de aplicativos.
NOTA
Para ter acesso ao menu de aplicativos, basta cli-
car sobre a região marcada em vermelho, na ima-
gem a seguir, e arrastar para cima. Os aplicativos 
implementados até o momento estão destacados 
em azul.
30 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Imagem 3.17 – Abrir o menu de aplicativos
Fonte: Elaborada pela autoria (2023).
Chamando a segunda Activity
Intenção de chamada
Para chamarmos a segunda tela (atividade) da aplicação, 
é necessário utilizar o objeto Intent. Esse objeto será descrito 
em detalhes adiante, portanto aqui será feita apenas uma breve 
introdução de sua sintaxe para permitir o funcionamento correto 
da aplicação em questão. Logo, para declarar uma chamada a 
outra atividade do mesmo aplicativo, devemos usar o seguinte 
fragmento de código:
Intent a = new Intent(this, Tela2.class);
startActivity(a);
31PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Nesse fragmento, podemos verificar, na primeira linha, 
a declaração de um objeto Intent “a”, que define a intenção de 
iniciar uma nova atividade, chamada Tela2.class. Já na segunda 
linha, vemos a utilização do comando startActivity, indicando como 
parâmetro a intenção de chamada. Como foi visto no princípio 
deste capítulo, o comando startActivity inicia uma atividade e não 
espera retorno algum dela.
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. Dessa forma, a simples 
implementação do código apresentado no item Intent não vai 
iniciar uma nova atividade, pois o evento que dispara essa ação 
não foi definido. Apesar de o assunto layout ser tratado mais 
adiante neste material, vamos ver a seguir 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”;
Essas duas linhas de código declaram um objeto do tipo 
Button (botão) e definem “ok” como sendo o texto que deve apa-
recer no botão. Porém, a aplicação precisa saber que esse botão 
deve ser “ouvido” quando for clicado para executar uma nova ta-
refa. Dessa forma, devemos inserir a seguinte linha de código ao 
fragmento anterior:
32 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
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, podemos 
declarar a intenção (Intent) de chamar a nova tela. Toda vez que 
permitimos que um botão reaja a um clique, devemos implementar 
o método onClick para definir o que ele deve fazer quando for 
clicado. Desse modo, dentro da própria atividade, devemos criar 
um método onClick, assim:
public void onClick(View v) {
Intent i = new Intent(this, Tela2.class); 
startActivity(i); 
}
Podemos também modificar 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 
anteriormente. O botão deve ter como rótulo o texto “Clique 
Aqui”. Nesse exemplo, modificamos 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”.
Logo, o código completo da atividade da tela principal do 
aplicativo deve ficar da seguinte maneira:
33PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Imagem 3.18 – Código para o exemplo anterior
Fonte: Elaborada pela autoria (2023).
Veja que foi necessário inserir várias linhas e modificar 
algumas outras. Não se preocupe em entender tudo isso agora. 
Esse exemplo foi apenas para que você entenda as bases da 
funcionalidade de apps Android. Perceba também que, na linha 
21, da imagem anterior, o método startActivity é utilizado para 
chamar a atividade 2 (Tela2) da aplicação. Ela foi utilizada porque 
a tela principal não precisa, nesse caso, de retorno. Se você salvá-
34 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
lo e executá-lo, o AVD deve se parecer com o mostrado na imagem 
a seguir.
Imagem 3.19 – Resultado do exemplo anterior
Fonte: Elaborada pela autoria (2023).
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, a primeira tela 
para temporariamente (pause) e fica em segundo plano. Nesse 
momento, ambas as telas ocupam espaço na memória, além de 
recursos do dispositivo. Pressionando a tecla “Voltar”, em destaque 
na imagem mostrada, a segunda tela para temporariamente 
(pause), depois definitivamente (stop) e, por fim, é destruída 
(destroy). Já a primeira tela volta ao primeiro plano (resume). Nesse 
momento, apenas a tela principal ocupa espaço na memória e nos 
recursos do dispositivo.
Pressionando mais uma vez a tecla “Voltar”, a primeira 
tela para temporariamente (pause), depois para definitivamente 
35PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
(stop) e, por fim, é destruída (destroy), liberando toda a memória 
utilizada para a aplicação.
Em relação a isso, você pode estar pensando que um botão 
que ocupa todo o espaço da tela não adianta muita coisa. Seria 
interessante colocar mais componentes em uma mesma tela.
Perfeito! Você tem toda a razão! Logo aprenderemos a 
fazer isso. No próximo capítulo, veremos como fazer uma tela 
“conversar” com a outra por meio de parâmetros e como manipular 
layouts. Sigamos em frente!
RESUMINDO
E então? Gostou do que lhe mostramos? Aprendeu 
mesmo tudinho? Agora, só para termos certeza de 
que você realmente entendeu o tema de estudo 
deste capítulo, vamos resumir o que vimos.
Aqui, você aprendeu tudo sobre a navegabilidade, 
a intenção e o evento de chamada. Esperamos que 
tenha gostado do conteúdo apresentado. Avante!
36 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Passagem de parâmetros entre 
telas
OBJETIVO
Ao término deste capítulo, você será capaz de en-
tender como funciona a passagem de parâmetros 
entre telas. Animado para este novo conhecimen-
to? Vamos lá!
Entendendoa passagem de 
parâmetros entre as telas 
A passagem de parâmetros a ser estudada agora não 
cria vínculo entre as telas. Seu foco é a passagem de 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 utilizarmos 
o objeto Bundle (android.os.Bundle). A palavra “bundle” pode ser 
traduzida como “pacote” ou “embrulho”, e essa é exatamente a 
sua função, ou seja, servir como um embrulho ou um pacote com 
os dados que precisam ser passados de uma atividade para outra. 
Assim, para definirmos um objeto do tipo Bundle, utilizamos a 
seguinte sintaxe:
Bundle = new Bundle;
Um exemplo seria:
Bundle pacote_de_dados = new Bundle;
37PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Porém, é necessário definirmos o conteúdo desse pacote 
de dados, e, para tanto, precisamos 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”. Nesse sentido, podem ser adicionados vários 
dados a um mesmo pacote de dados. No entanto, uma vez que 
o seu conteúdo esteja definido, é necessário incorporá-lo a uma 
intenção de chamada, pois ele de nada vale se não for passado 
adiante.
Dessa forma, utilizamos o método putExtras para 
incorporar o pacote de dados a uma Intent:
i.putExtras(pacote_de_dados); startActivity(i);
O código completo fica assim:
38 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
… 
{
//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 dados chamado 
“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! Vamos 
acompanhar o próximo exemplo 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 imagem a 
seguir.
39PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Imagem 3.20 – App3_U3 – Código da classe Principal.java
Fonte: Elaborada pela autoria (2023).
A primeira coisa a fazer é alterar o código anterior para que 
fique idêntico ao apresentado na imagem 3.20. Assim, podemos 
mencionar que, na imagem 3.22, foram destacados os “imports” 
de bibliotecas e o método onCreate, para que você perceba 
claramente as alterações necessárias.
A imagem a seguir mostra o código anterior (3.20) com as 
alterações necessárias para ficar igual ao código da imagem 3.20. 
Preste atenção às modificações em destaque.
40 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Imagem 3.21 – App3_U3 – Código da classe Principal.java
Fonte: Elaborada pela autoria (2023).
Muito bem. O próximo passo é inserirmos as modificações 
referentes à passagem de parâmetros entre as telas. O nosso 
código fica assim:
41PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Imagem 3.22 - App3_U3 – Código da classe Principal.java
Fonte: Elaborada pela autoria (2023).
Em vermelho, estão destacadas as linhas que foram 
alteradas ou incluídas. Vamos, então, entender 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 dos apps Android. Dentro 
do método onCreate, um botão “b” deve ser criado; para ele, é 
definido o texto “Clique Aqui” (linha 15). Já na linha 16, definimos 
que esse botão deve “escutar” uma ação de click, isto é, a partir da 
execução dessa linha de código, o botão “b” deve reagir, chamando 
o método onClick quando for acionado. Então, o método onClick 
executa as seguintes atividades:
42 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
//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 chamado 
“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 essa explicação, 
ainda não existe a Tela2, necessária para o funcionamento correto 
do código descrito. Então, vamos inserir uma nova tela (Activity) 
chamada de Tela 2. Ela deve ter o seguinte código:
43PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Imagem 3.23 - App3_U3 – Código da classe Tela2.java
Fonte: Elaborada pela autoria (2023).
Vamos compreender melhor o código da imagem 3.23. 
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 desse 
código, é definida uma caixa de texto (TextView), de nome “txt”. Na 
linha 14, é definida uma variável com o nome de “msg_recebida”, 
e a ela é atribuído o conteúdo vazio. Já na linha 15, é definido um 
objeto “Intent”, que, nesse caso, serve para capturar a intenção 
de chamada realizada pela tela principal. Na linha 16, verifica-se 
se a intenção de chamada capturada não está vazia (nula). Caso 
44 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
não seja nula, é executada a linha 18, a qual captura um suposto 
pacote, enviado pela tela principal, nessa intenção de chamada.
Perceba que o pacote pode estar vazio, isto é, a intenção 
de chamada pode existir, mas não necessita possuir parâmetros. 
Essa verificação é feita na linha 19, e, caso exista algum pacote de 
dados embutido nessa intenção de chamada, ele é capturado na 
linha 21.
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 essa caixa de texto, é apresentado na tela do dispositivo.
Salvando e executando o código, obtemos o seguinte 
resultado:
Imagem 3.24 – Resultado do exemplo – Passagem de parâmetros entre telas
Fonte: Elaborada pela autoria (2023).
45PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Que tal? Esperamos que perceba como os conceitos e os 
códigos estudados nas unidades anteriores desta disciplina estão 
sendo aplicados agora. Vamos em frente!
RESUMINDO
E então? Gostou do que lhe mostramos? Aprendeu 
mesmo tudinho? Agora, só para termos certeza de 
que você realmente entendeu o tema de estudo 
deste capítulo, vamos resumir o que vimos.
Aqui, você aprendeu sobre a passagem dos parâ-
metros entre as telas. Esperamos que você tenha 
gostado do conteúdo apresentado. Avante!
46 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Inserindo componentes na tela
OBJETIVO
Ao término deste capítulo, você será capaz de 
entender os passos para inserir os componentes 
na tela do aplicativo Android. E aí, animado para 
mais um desafio? Vamos lá!
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 por 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 entendermos melhor esse assunto, vamos criar 
um novo projeto no Android Studio na versão Android 4.0.3. É 
importante salientarmos que pode haver mudanças nas versões 
maisrecentes dos conceitos que serão apresentados. Vamos, 
então, revisar os passos em detalhes, como apresentado a seguir:
1. Abra o Android Studio e crie uma nova aplicação 
Android.
2. Defina o nome da aplicação 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 de o projeto estar carregado, clique em executar 
(Run), selecione o AVD para exibir o app, e o resultado 
deve ser como o apresentado a seguir:
47PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Imagem 3.25 – AVD do exemplo
Fonte: Elaborada pela autoria (2023).
Até aqui, você já sabe o que fazer. Vamos, então, aprofundar 
nosso conhecimento.
Entendendo o leitor de layout
Nesse ponto, é necessário explicarmos como funciona 
o editor de layout disponibilizado pelo Android Studio, além de 
verificar como cada alteração de layout em uma Activity (tela do 
app) impacta o código xml correspondente. Sendo assim, selecione 
o arquivo xml referente ao layout da aplicação, clicando em app -> 
res -> layout e escolhendo o arquivo activity_principal.xml, como 
mostrado na imagem a seguir.
48 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Imagem 3.26 – Selecionando o arquivo xml de layout da tela do dispositivo
Fonte: Elaborada pela autoria (2023).
Ao selecionar o arquivo de layout, conforme demonstrado 
anteriormente, o Android Studio apresenta o editor de layout. Esse 
recurso permite que você crie o layout desejado para cada uma 
das telas de sua aplicação, clicando e arrastando elementos para 
um preview de tela do AVD escolhido. O editor de layout de nosso 
app é apresentado na imagem a seguir.
49PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Imagem 3.27 – Editor de layout do app
Fonte: Elaborada pela autoria (2023).
Na parte superior da imagem anterior, estão destacados 
em vermelho o AVD, a API e o tema que utilizaremos nesse projeto. 
Quanto a isso, é possível que o tema de seu projeto ainda não 
esteja definido como na imagem 3.27; logo, clique sobre o tema 
e o selecione para ficar igual ao apresentado na referida imagem, 
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; 
então, selecione o tema “Light”, como mostrado na imagem a 
seguir.
50 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Imagem 3.28 – Seleção de tema para o app
Fonte: Elaborada pela autoria (2023).
Como vimos, no canto inferior esquerdo da imagem 
3.27, há duas abas em destaque. A primeira (Design) mostra o 
editor de 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 apresentado na imagem a seguir.
Imagem 3.29 – Arquivo xml correspondente ao layout da tela do app
Fonte: Elaborada pela autoria (2023).
51PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Como comentamos antes, cada tela (Activity) possui 
um arquivo xml de layout. Note que o elemento “TextView”, que 
visualizamos na imagem 3.27, com o conteúdo “Hello World”, 
aparece no arquivo xml (da linha 9 até a linha 16) e que esse 
conteúdo está definido na linha 12.
Agora experimente trocar o conteúdo desse 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 o apresentado na imagem 
a seguir.
Imagem 3.30 – Apresentação do layout do app
Fonte: Elaborada pela autoria (2023).
Perceba também que o conteúdo do atributo “text”, 
destacado em vermelho, do lado direito da imagem anterior 
também foi alterado.
Agora faça outro teste: altere o conteúdo da caixa de texto 
(destacada em vermelho) para “Tela Principal do App” e pressione 
a tecla ENTER. Esse ato terá duas consequências: (1) o conteúdo 
52 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
do elemento TextView, destacado em vermelho, no lado esquerdo 
da imagem 3.30, que está posicionado no meio da tela do AVD, 
será alterado. Clicando na aba Text, você perceberá que o arquivo 
xml também foi alterado na linha 12, conforme apresentado na 
imagem a seguir.
Imagem 3.31 – Elemento TextView
Fonte: Elaborada pela autoria (2023).
A conclusão é óbvia, mas precisa ser mencionada aqui: 
qualquer alteração no arquivo xml causa alterações no layout do 
app ou em algum atributo de um dos componentes de sua tela. 
Além disso, qualquer alteração no layout do app ou em qualquer 
atributo dos elementos que compõem sua tela causa alterações 
no arquivo xml.
Portanto, 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 de nossos estudos. Uma vez que você já conheça 
um pouco do editor de layout e de sua relação com o arquivo xml, 
vamos em frente para entender como inserir componentes na tela 
do app.
53PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Primeiro, precisamos mudar o layout da tela. Se olharmos 
com atenção para a linha 2 da imagem 3.29, perceberemos que o 
layout definido até o momento para nosso app é o ConstraintLayout. 
Vamos, então, mudar essa especificação para um tipo de layout 
mais simples e de mais fácil entendimento: 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 elementos que estão presentes 
na tela de seu app até o momento, da seguinte maneira:
Imagem 3.32 – Árvore de componentes do app
Fonte: Elaborada pela autoria (2023).
Clique com o botão direito do mouse sobre o referido 
layout e selecione o item “Convert View...”; uma tela com os 
layouts disponíveis será apresentada. Nessa nova tela, selecione 
“LinearLayout” e clique no botão “Apply”, como apresentado na 
imagem a seguir.
54 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Imagem 3.33 – Alterando o layout da tela do app
Fonte: Elaborada pela autoria (2023).
A janela que apresenta a “Árvore de Componentes” deve 
ser alterada para informar que o layout do app passou a ser 
definido como LinearLayout (horizontal). No entanto, 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 na imagem a 
seguir.
55PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Imagem 3.34 – Alterando a orientação do layout para a vertical
Fonte: Elaborada pela autoria (2023).
Se você clicar na aba Text, verá o seguinte código xml:
Imagem 3.35 – Arquivo xml da tela do app depois de ter o layout definido para LinearLayout
Fonte: Elaborada pela autoria (2023).
56 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
IMPORTANTE
Os tipos de layout e suas características serão vistos 
mais adiante neste material. Por ora, estamos 
apenas introduzindo o assunto.
Perceba a diferença entre o arquivo da imagem 3.35 
e o arquivo xml da imagem 3.34. Agora que o layout da tela 
está devidamente configurado, precisamos aprender a inserir 
componentes em nosso app.
TextView
O componente TextView é um rótulo ou uma etiqueta 
(label) em que podemos escrever um texto que pode ser lido, 
mas não pode ser alterado pelo usuário do app. Neste segmento, 
vamos primeiramente deletar o componente Textview que já existe 
(apenas para praticar) e adicionar um novo.
Assim, para deletar o componente TextView (ou qualquer 
outro que você deseje), clique na aba Design para visualizar o 
editor de layout do AVD. Em seguida, clique sobre o componente 
TextView, cujo texto é “Tela principal do 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 na 
imagema seguir.
57PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Imagem 3.36 – Janela “Palette”
Fonte: Elaborada pela autoria (2023).
Agora 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 
dela, como mostra a imagem a seguir.
58 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Imagem 3.37 – TextView inserido na tela do AVD
Fonte: Elaborada pela autoria (2023).
Repare que, se você clicar sobre o componente TextView 
inserido, aparecerá, do lado direito da tela, uma janela com as 
propriedades (atributos) desse componente. Podemos perceber 
claramente que o componente possui um identificador único, 
chamado ID, cujo valor é TextView2. Ele possui também duas 
propriedades parecidas, chamadas de layout_width e layout_
height, as quais definem suas propriedades de largura e altura 
respectivamente. Para cada uma dessas propriedades, podemos 
ter três valores diferentes, a saber:
(1) Match_parent: define que o objeto deve ter a mesma 
largura (width) e/ou altura (height) do componente no qual ele 
está contido. Para esse caso em específico, sabemos que o 
componente TextView está contido no componente LinearLayout. 
Assim, podemos provar isso ao analisar a janela “Component Tree”, 
que destaca claramente essa característica.
59PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
(2) Outro valor possível é wrap content. Se esse valor for 
escolhido para essa propriedade, a largura (width) e/ou a altura 
(height) do componente TextView serão ajustadas ao tamanho 
do texto que ele possui. É importante destacarmos que, se o 
componente não tiver valor para a propriedade de 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 caixa de combinação e selecionar um dos itens apresentados 
em uma tela especial.
Logo depois dessas propriedades, existe uma propriedade 
chamada “text”, que define o texto a ser apresentado pelo 
componente “TextView” na tela do AVD. Assim, defina para essa 
propriedade o seguinte valor: “Bem-vindo ao meu app. Digite seu 
nome e clique em OK para entrar”. Em seguida, 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 a altura dele, para ficar parecido com a imagem 
a seguir.
Imagem 3.38 – Componente “TextView” no editor de layout
Fonte: Elaborada pela autoria (2023).
60 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Salve e execute o aplicativo. O resultado deve ser como o 
apresentado na imagem a seguir.
Imagem 3.39 – Componente “TextView” com o aplicativo em execução
Fonte: Elaborada pela autoria (2023).
Note que você pode alterar outras propriedades do 
componente “TextView”, tais como tipo, cor e tamanho da fonte, 
entre outras, como mostra a imagem a seguir.
61PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Imagem 3.40 – Propriedades do componente “TextView”
Fonte: Elaborada pela autoria (2023).
A frase que aparece no componente “TextView” nos dá 
uma deixa para aprendermos a inserir dois novos componentes: 
o “Plain Text” e o “Button”. Então, vamos lá!
62 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Plain Text
O “Plain Text” é uma caixa de texto que permite ao usuário 
digitar algo. Ele tem os mesmos atributos que o componente 
“TextView” e mais um, chamado de “Input Type”, o qual define o 
tipo de dado que esse componente vai receber. Nesse sentido, 
podemos definir o conteúdo da propriedade “text” como vazio, 
afinal o usuário vai digitar o seu nome ali.
Para incluir esse 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:
Imagem 3.41 – AVD com “TextView” e “Plain Text”
Fonte: Elaborada pela autoria (2023).
Aqui podemos notar algumas características. 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. Você pode alterar essa 
propriedade para dar uma dica ao usuário, caso queira. Além disso, 
esse componente, chamado android:inputtype, é responsável por 
definir o tipo de dado que receberá. Ele pode conter valores como 
63PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
text, date, time, datetime, numberDecimal, number, textPassword, 
entre outros. Você também pode alterar outras propriedades, 
conforme apresentamos na imagem a seguir.
Imagem 3.42 – Propriedades do componente “PlainText”
Fonte: Elaborada pela autoria (2023).
Button
Agora precisamos inserir um botão com o texto “OK”. Para 
isso, selecione o item Button -> Button, na janela “Palette”, como 
apresentado na imagem a seguir.
64 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Imagem 3.43 – Inserindo um botão
Fonte: Elaborada pela autoria (2023).
Insira o botão na tela, altere seu tamanho e troque o valor 
de sua propriedade “text” de “Button” para “OK”. Ao ser salvo e 
executado, o app deve ficar mais ou menos assim:
Imagem 3.44 – AVD com “TextView”, “Plain Text” e “Button”
Fonte: Elaborada pela autoria (2023).
Antes de passarmos para o próximo componente, clique 
na aba “Text” e verifique o arquivo xml correspondente a essa 
Activity que acabamos de fazer. Ela deve estar parecida com a 
imagem a seguir.
65PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Imagem 3.45 – Arquivo xml correspondente ao AVD da imagem 3.42
Fonte: Elaborada pela autoria (2023).
Repare como os componentes estão descritos 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 imagem a seguir.
66 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Imagem 3.46 – Janela “Palette”
Fonte: Elaborada pela autoria (2023).
Antes de inserirmos mais componentes, como o “Radio 
Button”, vamos criar outra Activity (tela) para o nosso app. Essa 
Activity deve ser chamada de “Tela2” e deve ser uma Empty Activity. 
Depois de criar a nova Activity, não se esqueça de mudar o layout 
para LinearLayout (vertical), assim como fizemos com a Activity 
principal.
Isso posto e realizado, podemos inserir o “radio button”. 
Para tanto, selecione o item “Buttons” e perceba que existem dois 
componentes que começam com o nome Radio: “RadioGroup” e 
67PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
“RadioButton”. Primeiro, selecione o “RadioGroup” e o arraste para 
a tela do AVD. Depois, selecione três componentes “RadioButton” 
e os arraste para o interior do “RadioGroup” que você acabou de 
inserir. Seu projeto deve ficar como mostra a imagem a seguir.
Imagem 3.47 – Inserindo “Radio Buttons” na Activity
Fonte: Elaborada pela autoria (2023).
Para melhorar o layout dessa Activity, selecione o 
componente “RadioGroup”, defina ambos os valores das 
propriedades “layout_width” e “layout_height” para “wrap_content”. 
Sua tela deve ficar assim:
68 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Imagem 3.48 – Melhorando o layout da imagem 3.44
Fonte: Elaborada pela autoria (2023).
Repare que todos os componentes “RadioButtons” tem o 
mesmo valor para a propriedade “text”. Clique no primeiro e defina 
essa propriedade para “Aluno”. Defina também, para o segundo, o 
valor “Professor” e, para o terceiro, o valor “Outro”. Sua tela deve 
ficar assim:
Imagem 3.49 – Projetando a Activity 2 do app
Fonte: Elaborada pela autoria (2023).
Vamos inserir agora um “TextView” com o seguinte texto: 
“Qual é sua posição nesta instituição?”.
69PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Podemos imaginar que esse app seja direcionado a uma 
instituição de ensino. Clique e arraste o componente “TextView” 
de maneira que ele fique acima do “RadioGroup”. A tela deve ficar 
assim:
Imagem 3.50 – Projetando a Activity 2 do app
Fonte: Elaborada pela autoria (2023).
Não se esqueça de 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 esses componentes, use os mesmos recursos 
aprendidos até o momento. Sua tela deve ficar como a apresentada 
na imagem a seguir.
70 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Imagem 3.51 – Projetando a Activity 2 do app
Fonte: Elaborada pela autoria (2023).
Bom, você já deve ter percebido a quantidade de 
componentes que pode utilizar para montar um app. Entã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!
71PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Imagem 3.52 – Alterando propriedades de cada elemento da tela
Fonte: Elaborada pela autoria (2023).
No caso do elemento “ComboBox”, ele está definido como 
Container -> Spinner na janela “Palette”, como mostrado na imagem 
a seguir.
Imagem 3.53 – Componente “ComboBox”
Fonte: Elaborada pela autoria (2023).
72 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Outro aspecto importante é que, para definir seu conteúdo, 
é necessário criar um array de opções no arquivo strings.xml, 
dentro da pasta “values”. Sua localização é apresentada na imagem 
a seguir.
Imagem 3.54 – Localização do arquivo string.xml
Fonte: Elaborada pela autoria (2023).
Nesse caso, precisamos inserir um array com os valores 
“masculino” e “feminino” dentro desse arquivo. Para tanto, clique 
sobre o arquivo e digite o código apresentado na imagem a seguir.
Imagem 3.55 – Arquivo string.xml
Fonte: Elaborada pela autoria (2023).
73PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
O que você precisa digitar está destacado em vermelho 
na imagem. Já aquilo que está em azul é outro exemplo para 
você perceber como o processo segue o mesmo padrão. Uma 
vez que você tenha digitado o código do arquivo xml, conforme 
apresentado na imagem anterior, volte para o editor de layout da 
tela 2, clique no componente “Combobox” (spinner) e verifique suas 
propriedades. Uma delas será a “entries”. Clique no botão ao lado 
dessa propriedade, e você verá mais ou menos o que mostra a 
imagem a seguir.
Imagem 3.56 – Criando valores para o componente “ComboBox”
Fonte: Elaborada pela autoria (2023).
Em destaque, na imagem anterior, podemos verificar que, 
ao clicarmos no link da propriedade “entries”, a tela “Resources” é 
apresentada.
Do lado esquerdo, selecione a opção “Array”, destacada em 
azul, e você terá acesso a todos os arrays definidos no arquivo 
string.xml, entre os quais estão o array que trata de “estado civil” e 
o que trata de “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á funcionando, salve seu 
projeto e execute-o. Note que apenas a primeira tela (Principal) 
aparece e que aparentemente não temos como acessar a tela 
74 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
2 para verificar os demais componentes. Nesse caso, existem 
duas soluções possíveis: você pode fazer o mesmo processo que 
fizemos no capítulo 2 desta unidade ou você pode fazer a seguinte 
alteração:
1. Abra o arquivo AndroidManifest.xml. Ele deve se 
parecer como o apresentado a seguir.
Imagem 3.57 – Arquivo AndroidManifest.xml
Fonte: Elaborada pela autoria (2023).
Note que, destacados em vermelho, estão os comandos 
que permitem ao Android Studio saber qual das telas deve ser a 
primeira a ser aberta quando o aplicativo for executado.
2. Faça uma alteração nesse código para que o que 
estudamos na primeira unidade desta disciplina passe 
da tela Principal para a Tela 2, da seguinte maneira:
75PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Imagem 3.58 – Alterando a tela inicial do aplicativo
Fonte: Elaborada pela autoria (2023).
Salve o arquivo e execute a aplicação. Você verá que a Tela 
2 é apresentada e deve se parecer com a imagem a seguir.
Imagem 3.59 – Tela 2 da aplicação
Fonte: Elaborada pela autoria (2023).
76 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
Bem, certamente já vimos muita coisa. Não se esqueça 
de testar, criar, inventar, modificar as propriedades e verificar 
seus efeitos. Na próxima unidade, veremos como tratar os 
eventos gerados pelos componentes vistos aqui. Não se esqueça 
de se aprofundar nos conhecimentos, acessando as referências 
apresentadas.
RESUMINDO
E então? Gostou do que lhe mostramos? Aprendeu 
mesmo tudinho? Agora, só para termos certeza de 
que você realmente entendeu o tema de estudo 
deste capítulo, vamos resumir o que vimos.
Você deve ter aprendido como inserir componentes 
na tela. Esperamos que tenha aproveitado ao 
máximo todo o conteúdo apresentado.
77PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 3
CLARO, D.; SOBRAL, J. Programação em JAVA. Florianópolis: 
Copyleft Pearson Education, 2008. 89 p. Disponível em: https://
www.faeterj-rio.edu.br/downloads/bbv/0031.pdf. Acesso em: 8 
dez. 2023.
CORDEIRO, F. Android Studio. 3. ed. [S. l.]: AndroidPro, 2016.
CORDEIRO, F. Android aprendiz. [S. l.]: AndroidPro, 2017. 37 p. 
Disponível em: https://www.androidpro.com.br/. E-book. Acesso 
em: 8 dez. 2023. 
DALL’OGLIO, P. PHP: programando com orientação a objetos. 3. 
ed. SP: Novatec Editora, 2016.
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 software em Java. São Paulo: 
Digerati Books, 2007.
MEIRELLES, A. Smartphones, guia prático - android. Hardware.com.
br, 2009.
ORACLE.COM. Java Documentation. [S. l.]: Oracle, 2018. 
SINGH, C. @Override annotation. In: Java. Java Tutorial, 2017. 
RE
FE
RÊ
N
CI
A
S
	_Hlk156296831
	_Hlk156296744
	_Hlk156296522
	_Hlk156296664
	_Hlk156296551
	_Hlk156296213
	_Hlk156296239
	_Hlk156296263
	_Hlk156296425
	_Hlk156296281
	Ciclo de vida do aplicativo Android e 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
	Entendendo a passagem de parâmetros entre as telas 
	Inserindo componentes na tela
	Entendendo o leitor de layout
	TextView
	Plain Text
	Button
	Radio Button
	Check Box e Combo Box