E-book da Unidade - Eventos e Resultados na Interface do App

Prévia do material em texto

PROGRAMAÇÃO 
CODING (MOBILE)
Unidade 4
Eventos e 
resultados na 
interface do app
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
 4
A
U
TO
RI
A
Luiz Fernando Corcini
Olá. Sou graduado 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 e 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!
5PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
ÍC
O
N
ESEsses í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
 4
SU
M
Á
RI
O
Tratamento de eventos ............................................................ 9
Definindo o protótipo da aplicação .................................................................. 9
Implementando a aplicação .............................................................................10
Preparando a tela principal ...............................................................11
Preparando a tela2 .............................................................................16
Preparando a tela3 .............................................................................20
Capturando resultados de uma atividade ............................ 24
Preparando as telas da aplicação ...................................................................28
Capturando a seleção do usuário ..................................................................31
Retornando o item selecionado ......................................................................33
Chamando ações do sistema Android .................................... 36
ACTION_VIEW ......................................................................................................36
ACTION_PICK .......................................................................................................41
ACTION_CALL ......................................................................................................43
Layout de tela ........................................................................... 47
Entendendo o layout de tela ...........................................................................47
FrameLayout .......................................................................................................47
LinearLayout .......................................................................................................53
Relevância dos componentes ........................................................... 55
TableLayout .........................................................................................................59
Atributo StretchColluns ........................................................................61
Atributo ShrinkColluns .........................................................................65
Combinando layouts ...........................................................................67
7PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
A
PR
ES
EN
TA
ÇÃ
O
Seja bem-vindo! Nesta unidade, vamos projetar e 
desenhar telas para aplicativos móveis, aplicando-lhes técnicas de 
usabilidade e recursos disponíveis no sistema Android, por meio da 
linguagem Java Mobile. É claro que existe muito mais a aprender, 
mas o aprofundamento de cada um desses conhecimentos 
pode ser feito acessando o link indicado durante o texto, nos 
iconográficos. Vamos começar? Excelente estudo para você!
8 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
O
BJ
ET
IV
O
S
Olá. Seja muito bem-vindo à Unidade 4. Nosso objetivo 
é auxiliar você no desenvolvimento das seguintes competências 
profissionais até o término desta etapa de estudos:
1. Formatar telas de aplicativos para dispositivos móveis 
baseados no sistema operacional Android.
2. Obter e tratar dados provenientes das mais diversas 
atividades em um aplicativo Android, por meio da 
linguagem Java Mobile. 
3. Invocar ações dos recursos residentes no sistema 
operacional Android.
4. Projetar e desenhar telas para aplicativos móveis, 
aplicando-lhes técnicas de usabilidade e recursos 
disponíveis no sistema Android, por meio da linguagem 
Java Mobile.
Vamos, então, rumo ao conhecimento. Bons estudos!
9PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Tratamento de eventos
OBJETIVO
Ao término deste capítulo, você será capaz 
de entender como acontece o tratamento de 
eventos. E então? Motivado para desenvolver essa 
competência? Então vamos lá. Bom estudo!
O termo “evento”, no contexto desta disciplina, pode 
ser definido como a ação do usuário sobre algum componente 
apresentado na tela, isto é, podemos considerar que a cada 
interação do usuário com o aplicativo, em geral, ocorre um evento 
que pode ser identificado e tratado.
SAIBA MAIS
A maioria dos aplicativos desenvolvidos para 
dispositivos móveis necessita da interação do 
usuário para seu funcionamento correto. O usuário 
deve fazer escolhas, clicar em botões, selecionar 
itens em uma lista ou marcar a opção desejada.
Agora, vamos aprender a como tratar os eventos que o 
usuário pode realizar com esses componentes. Para tanto, vamos 
criar uma aplicação simples. Siga com atenção os passos descritos 
a seguir.
Definindo o protótipo da 
aplicação
Todo projeto precisa de um protótipo, no qual podemos 
entender o funcionamento do app e quais componentes são 
necessários para que ele seja executado adequadamente. Sendo 
assim, a imagem a seguir apresenta o protótipo do projeto, 
exemplo que usaremos para tratar os eventos: 
10 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Imagem 4.1 – Protótipo da aplicação Android
Fonte: Elaborada pela autoria (2023).
Percebe-se, pela imagem anterior, que nossa aplicação 
será composta por três telas (activity). Na primeira tela (Principal), 
vamos precisar utilizar três tipos de componentes: (1) dois 
TextView; (2) um Plain Text; e (3) um Button. Na segunda tela, vamos 
precisar de quatro tipos de componentes: (1) seis do tipo TextView; 
(2) dois do tipo Plain Text; (3) dois do tipo Option Buton; (4) um do 
tipo Button. Por fim, na terceira tela, precisaremos desses tipos de 
componentes: (1) dois do tipo TextView; (2) dois do tipo Button; (3) 
um do tipo PlainText.
Implementando a aplicação
Para implementar a aplicação, abra o Android Studio e crie 
uma nova aplicação, chamada App_Evento_U4, com uma “Empty 
Activity”, chamada Principal. Depois do projeto estar carregado 
na IDE Android Studio, insira mais duas telas (Empty Activity) em 
seu projeto, com os nomes de Tela2 e Tela3, respectivamente. Seu 
projeto deve ficar assim:
11PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Imagem 4.2 – Telas da aplicação
Fonte: Elaborada pela autoria (2023).
Observe, na imagem anterior, que cada tela (classe Activity.
java) possui um arquivo xml (layout) correspondente. Trataremos 
cada uma delas a partir de agora.
Preparando a tela principal
Layout da tela
Abra o arquivo que corresponde ao layout da Tela Principal 
(activity_principal.xml) e insira os componentes conforme a imagem 
4.1. O código xml deve ficar assim:
12 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Imagem 4.3 – Arquivo xml layout da tela principal
Fonte: Elaborada pela autoria (2023).
Salve e execute o aplicativo. O AVD deve ser apresentado 
com o que mostra a imagem a seguir:
13PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Imagem 4.4 – Resultado do AVD para tela principal
Fonte: Elaborada pela autoria (2023).
Classe Activity da tela principal
Os eventos que devem acontecer na tela principal são: 
ao clicar no botão OK, o aplicativo deve capturar o nome do 
usuário digitado na caixa de texto e passá-lo como parâmetro 
para a tela 2.
IMPORTANTE
Perceba que o usuário pode clicar no botão OK 
sem digitar qualquer nome na caixa de texto 
correspondente e esse “erro” precisa ser tratado.
14 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Sendo assim, primeiro precisamos permitir ao aplicativo 
“ouvir” o clique do mouse sobre o botão. Isso é chamado de evento 
“listener”. Mas, se você está em dúvida, verifique o código na 
imagem a seguir:
Imagem 4.5 – Classe Activity para a tela principal
Fonte: Elaborada pela autoria (2023).
Nesse ponto, precisamos destacar dois casos: 
1. Repare que, na linha 25, para que possamos capturar 
o nome que o usuário escreveu, precisamos saber o 
nome do componente em que ele escreveu o nome: 
“txt_nome”. Demos esse nome porque é uma caixa de 
texto (txt) que supostamente terá como conteúdo o 
nome do usuário (nome). Por isso, “txt_nome”. O nome 
do componente foi dado quando montamos o arquivo 
xml do layout da tela principal (linha 19 – Imagem 4.3).
15PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
2. Observe que, na linha 28, existe uma verificação, se 
o conteúdo da caixa de texto onde o usuário deve 
digitar seu nome está vazia, o aplicativo apresenta 
uma mensagem de aviso e não executa a intenção de 
chamada para a tela2, isto é, caso o usuário esqueça 
de digitar o seu nome e clicar no botão OK, o aplicativo 
deve se comportar como mostrado na imagem a seguir:
Imagem 4.6 – Mensagem de aviso quando o nome do usuário é deixado em branco e o 
botão OK é pressionado
Fonte: Elaborada pela autoria (2023).
16 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Preparando a tela2
Layout da tela2
Conforme mostrado (Imagem 4.1), a tela2 possui vários 
componentes, e um deles deve receber o nome do usuário. 
Podemos imaginar que seja possivelmente o primeiro componente 
“TextView”, o qual contém o texto “Olá”. Primeiramente, vamos 
montar o arquivo xml que define o layout da tela2. O código deve 
ser como mostrado na seguinte imagem:
Imagem 4.7 – Código xml do layout da tela2
Fonte: Elaborada pela autoria (2023).
17PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Salve e execute o aplicativo. O AVD deve ser apresentado 
com o que mostra a imagem a seguir:
Imagem 4.8 – Resultado do AVD para tela2
Fonte: Elaborada pela autoria (2023).
Note que o nome do usuário ainda não está aparecendo. 
Precisamos tratar isso na classe java correspondente à tela2.
18 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Classe Activity da tela2
Agora que temos o layout da tela2 implementado, 
precisamos implementar o código java para que ela receba o 
parâmetro relativo ao nome do usuário. Também apresente o 
nome logo após a palavra “Olá”, e capture os dados digitados nos 
campos apresentados quando o usuário clicar no botão “Seguir”. 
Primeiro, vamos capturar o parâmetro, ou seja, o pacote de 
dados enviado pela tela principal. Para isso, usamos os métodos: 1 - 
getIntent() – para capturar a intenção de chamada; 2 - getExtras() – para 
recuperar o pacote de dados enviado; 3 -getSting() – para recuperar o 
parâmetro enviado. Veja como mostra a próxima imagem:
Imagem 4.9 – Código java da tela2 para capturar o parâmetro enviado pela tela principal
Fonte: Elaborada pela autoria (2023).
19PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
A seguir, salve e execute o aplicativo. O AVD deve ser 
apresentado com o que mostra a seguinte imagem:
Imagem 4.10 – Tela2 capturando o dado enviado pela tela principal
Fonte: Elaborada pela autoria (2023).
Repare, no código java (imagem 4.9), para inserir o conteúdo 
enviado por parâmetro para a tela2, na caixa de texto que contém 
a palavra “Olá”, precisamos saber o nome deste componente, que, 
neste caso, é “TextView5”. Ficaria muito mais fácil de se programar 
se o nome dado a esse componente fosse algo que lembrasse do 
que ele trata, por exemplo: “txt_ola”, não concorda? 
Foi por isso que, na imagem 4.7, destacados em vermelho, 
escolhemos nomes mnemônicos para os componentes que 
precisamos manipular. Agora que capturamos os dados, enviado 
pela tela principal, e o apresentamos na tela2, precisamos tratar 
o evento de clique no botão “Seguir”, na tela2. Da mesma forma 
que aconteceu na tela principal, precisamos prever que o usuário 
20 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
pode “esquecer” de preencher os campos e clicar direto no botão 
“Seguir”.
Imagem 4.11 – Código java da tela2 para capturar e enviar os dados de peso e altura 
digitados pelo usuário
Fonte: Elaborada pela autoria (2023).
Observe que, na imagem anterior, nas linhas 48, 49 e 50, 
três parâmetros são enviados para a tela3, quais sejam: nome, 
altura e peso do usuário. Vamos tratar, enfim, da tela3.
Preparando a tela3
Layout da tela3
Dando os nomes corretos aos componentes que serão 
utilizados, o arquivo xml da tela3, fica como mostrado na próxima 
imagem:
21PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Imagem 4.12 – Arquivo xml do layout da tela3
Fonte: Elaborada pela autoria (2023).
Repare que, nas linhas 12, 18 e 32 da imagem anterior, 
foram dados os nomes mnemônicos para os componentes, pois 
eles serão usados pelo código java.
Classe Activity da tela3
A imagem a seguir apresenta o código java da classe Activity 
que representa a tela3.
22 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Imagem 4.13 – Código java da tela3
Fonte: Elaborada pela autoria (2023).
O resultado deve ser como mostrado na imagem a seguir:
Imagem 4.14 – Resultado da aplicação
Fonte: Elaborada pela autoria (2023).
23PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
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 tudo o que vimos. 
Você deve ter aprendido sobre o tratamento 
de eventos, bem como definição do protótipo 
da aplicação, entre outros. Esperamos que 
tenha aproveitado ao máximo todo o conteúdo 
apresentado.
24 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Capturando resultados de uma 
atividade
OBJETIVO
Ao término deste capítulo, você será capaz de 
entender como capturar resultados de uma 
atividade, preparar as telas de aplicação, entre 
outros. E então? Motivado para desenvolver essa 
competência? Então vamos lá. Bom estudo!
A função do objeto “Intent” é a de declarar a intenção de 
iniciar outra atividade a partir de uma já em execução. Utilizando 
o objeto Intent, a atividade em execução pode: 1 - especificar qual 
outra atividade ela deseja iniciar – item que veremos neste tópico; 
2- descrever o tipo de ação que ela deseja realizar – item que 
veremos no capítulo 3 deste material. 
O sistema Android localiza a atividade apropriada para 
realizar a tarefa definida pela ação. É possível passar dados para 
a atividade que vai ser iniciada com o objeto Bundle (embrulho 
ou pacote de dados) e receber retorno dela, fazendo uso dos 
métodos startActivity() e startActivityForResult(). Até o momento, 
todos os exemplos apresentados utilizaram somente o método 
starActivity(). 
Agora que já foi compreendido como chamar uma nova 
atividade e como inserir alguns componentes nela, a aplicação 
pode se tornar mais complexa e pode haver a necessidade de 
capturar o retorno de uma atividade iniciada. Para tanto, utiliza-se 
o método starActivityForResult() no lugar do método starActivity(). 
Um exemplo comum para esse caso acontece quando o usuário 
necessita escolher um de seus contatos da lista para executar 
alguma ação com ele, como mandar uma mensagem, fazer uma 
ligação ou fazer qualquer coisa com a informação desse contato. A 
utilização do método startActivityForResult() faz com que a atividade 
25PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
que foi iniciada, ao ser concluída, retorne um resultado, na forma 
de Intent, para a atividade que a iniciou. 
Para iniciar o estudo, crie um novo projeto Android com as 
seguintes características: 
 • Nome da aplicação: “App_Intent_U4”;
 • Nome da atividade: “Principal”;
 • Na classe Atividade Principal, defina os seguintes 
componentes: um label (TextView) com o atributo text 
= “Esta é a Tela Principal”; e um Botão (Button) com o 
atributo text = “Seguir para a Próxima Tela”. O um label 
(textView) com o atributo text = “captura retorno”. 
Quando o botão for clicado, deve ser chamada uma 
nova tela (classe Atividade) chamada “Tela2”, com as seguintes 
características: 
 • Nome da atividade: “Tela2”;
 • Na segunda tela (Tela2), defina o seguinte componente: 
o TextView com o atributo text = “Esta é a segunda Tela 
do App”. Não se esqueça de mudar o tipo de layout para 
LinearLayout e definir sua orientação como “vertical”. 
Implementando o código xml para o layout das duas telas, 
descritas acima, temos para tela principal a imagem a seguir:
26 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Imagem 4.15 – Código xml para o layout da tela principal
Fonte: Elaborada pela autoria (2023).
Já para a Tela2 temos a imagem: 
Imagem 4.16 – Código xml para o layout da segunda tela do aplicativo
Fonte: Elaborada pela autoria (2023).
27PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Implementando o código java para as duas telas teremos, 
para a tela principal a imagem:
Imagem 4.17 – Código java para a tela principal
Fonte: Elaborada pela autoria (2023).
Enquanto para a Tela2, a imagem a seguir:
Imagem 4.18 – Código java para a Tela2
Fonte: Elaborada pela autoria (2023).
28 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Salve e execute a aplicação. O resultado deve ser o 
mostrado na próxima imagem:
Imagem 4.19 – Resultado da execução do aplicativo
Fonte: Elaborada pela autoria (2023).
Preparando as telas da aplicação
O próximo passo é modificar a segunda tela para que ela 
contenha algum componente que, ao ser selecionado pelo usuário, 
envie um retorno para a tela principal. Podemos, em um exemplo 
básico, montar uma lista das estações do ano, permitindo, assim, 
que o usuário selecione uma delas e este valor (da escolha do 
usuário) seja capturado e retornado. Para tanto, altere o código 
do arquivo layout xml da Tela2 para que ele fique da seguinte 
maneira:
29PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Imagem 4.20 – Novo código xml para a tela2
Fonte: Elaborada pela autoria (2023).
Observe que o atributo Android: entries (linha 28) do 
componente ListView é um array e deve ser definido no arquivo 
strings.xml, na subpasta res/values, da mesma maneira que foi feito 
quando inserimos o combobox para selecionar o sexo do usuário.
O arquivo strings.xml deve ficar como mostra a seguinte 
imagem:
30 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Imagem 4.21 – Arquivo strings.xml
Fonte: Elaborada pela autoria (2023).
E, por fim, a segunda tela deve ficar, como mostra a 
imagem a seguir:
Imagem 4.22 – Resultado tela2 depois das últimas alterações
Fonte: Elaborada pela autoria (2023).
31PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Capturando a seleção do usuário
Agora, é necessário aprender como capturar o item 
selecionado da lista de estações (componente ListView). Para tanto, 
modifique o código java da tela2 para ficar conforme mostra a 
imagem:
Imagem 4.23 – Código java para capturar a opção selecionada pelo usuário
Fonte: Elaborada pela autoria (2023). 
Fazendo essas alterações, salvando e executando o 
aplicativo, teremos o seguinte resultado:
32 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Imagem 4.24 – Resultado da captura da escolha do usuário
Fonte: Elaborada pela autoria (2023).
Repare que, ao clicar na opção “Inverno”, na tela do meio, 
essa opção aparece em destaque na tela à direita, por alguns 
segundos, e depois some. Ao selecionar outra opção (Estação), essa 
será apresentada. Isso acontece porque, no método onItemClick() 
(linha 21- 26, da imagem 4.23), temos um comando Toast.makeText 
responsável por essa ação. Explicando melhor o que acontece 
dentro deste método onItemClick(): 
 • Na linha 23, a estação escolhida pelo usuário é 
capturada do objeto View e passada para um objeto lbl 
do tipo TextView; 
 • Na linha 24, o conteúdo desse objeto é transformado 
em string e passado para uma variável chamada “texto”; 
 • Na linha 25, o método makeText(), do objeto Toast é 
responsável por apresentar uma mensagem de popup 
temporária. Esse método possui três parâmetros: (1) o 
contexto da aplicação; (2) o texto a ser exibido; e (3) a 
duração da mensagem.
33PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Retornando o item selecionado
Agora que o projeto está funcionando adequadamente, é 
hora de utilizar o método startActivityForResult() para permitir que 
a segunda tela (Tela2) devolva (retorne) o resultado selecionado 
pelo usuário para a tela principal. Para tanto, modifique o código 
da Tela Principal para que fique como mostra a seguir:
Imagem 4.25 – Classe Principal.java modificada para reconhecer o retorno da Tela2.java
Fonte: Elaborada pela autoria (2023).
34 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Por fim, modifique o código da segunda tela, para que ela 
fique como mostra a seguinte imagem:
Imagem 4.26 – Classe Tela2.java modificada para enviar item selecionado pelo usuário como 
retorno para a classe Principal.java
Fonte: Elaborada pela autoria (2023).
Salvando e executando o aplicativo, temos o seguinte 
resultado:
Imagem 4.27 – Resultado da captura do item selecionado pelo usuário
 
Fonte: Elaborada pela autoria (2023).
35PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Explicando o código: 
 • Na primeira tela: no método onClick(), em vez de 
utilizar o comando starActivity(), foi utilizado o comando 
startActivityForResult(), pois, para esse caso, queremos 
tratar o resultado da escolha do usuário na segunda 
tela. Os parâmetros desse comando sempre serão o 
objeto Intent e o número 0 (zero). 
Para tratar o resultado escolhido pelo usuário, 
implementou-se o método onActivityResult(), que sempre deve ser 
declarado quando o comando startActivityForResult() for utilizado. 
Dentro deste método (onActivityResult()), faz-se o teste para verificar 
se o objeto Intent foi retornado. Caso não tenha sido efetivado, 
isto é, caso a segunda tela tenha sido fechada sem que o usuário 
escolha algum item, a mensagem mostrada será: “Nenhum item 
selecionado”. Mas caso o usuário escolha algum item, antes de 
fechar a segunda tela, o valor escolhido é atribuído a um texto 
variável e mostrado na tela. 
 • Na segunda tela: a modificação acontece no método 
onItemClick() que, em vez de mostrar o resultado 
escolhido pelo usuário, declara um objeto Intentpara o 
qual é atribuído o valor escolhido por ele. Esse objeto 
é devolvido à tela principal, pelo método setResut, que 
terá acesso ao mesmo, logo que esta tela for fechada, 
e isso acontece quando o método finish() é executado.
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 tudo o que vimos. 
Aqui, você viu sobre capturar resultados de uma 
atividade, preparar as telas de aplicação, entre 
outros. Esperamos que tenha aproveitado ao 
máximo todo o conteúdo apresentado.
36 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Chamando ações do sistema 
Android
OBJETIVO
Ao término deste capítulo, você será capaz de 
entender como funcionam as ações do Sistema 
Android. E então? Motivado para desenvolver essa 
competência? Então vamos lá. Bom estudo!
O objeto Intent também pode chamar ações e permitir 
que o sistema Android escolha qual aplicativo deve executá-lo. 
Apresentaremos, neste tópico, algumas ações que o objeto Intent 
suporta. 
ACTION_VIEW
A ação Intent.ACTION_VIEW é a mais comum utilizada pelos 
programadores para mostrar dados para o usuário. Imagine 
que seu aplicativo precisa, em um determinado momento, abrir 
o navegador em algum site específico. Isso pode ser feito com o 
ACTION_VIEW, de acordo com o exemplo a seguir.
EXEMPLO: Uri endereco = Uri.parse(“http://www.
google.com”); Intent i = new Intent(Intent.ACTION_VIEW, 
endereco); startActivity(i);
37PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Para verificar o funcionamento dessa ação do objeto Intent, 
crie um novo projeto no Android Studio, chamado App_ACTION_U4, 
com uma Empty Activity chamada Principal. Ela deve conter um 
botão que, ao ser clicado, abre o navegador na página definida 
pela variável “endereço”. O Código xml do layout da aplicação deve 
ficar como mostrado na seguinte imagem: 
Imagem 4.28 – Código xml para o exemplo
Fonte: Elaborada pela autoria (2023).
O código java, por sua vez, deve ficar como a imagem a 
seguir:
38 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Imagem 4.29 – Código Java para o exemplo
Fonte: Elaborada pela autoria (2023).
Salvando e executando o aplicativo, tem-se o seguinte:
Imagem 4.30 – Resultado do exemplo
Fonte: Elaborada pela autoria (2023).
39PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
EXEMPLO: ainda utilizando a ação Intent.ACTION_VIEW, 
pode-se iniciar o aplicativo “agenda de contatos” da 
seguinte forma: 
Uri contato = Uri.parse(“content://com.Android.contacts/
contacts/1”); Intent i = new Intent(Intent.ACTION_VIEW, 
contato); startActivity(i); 
O número 1 na primeira linha do código acima indica qual 
“id” do contato deve ser visualizada.
IMPORTANTE
Para que essa chamada retorne o comando 
solicitado, deve-se entrar no aplicativo 
correspondente e cadastrar alguns contatos. 
Caso contrário, o aplicativo “lista de contatos” 
avisará que não existe contato cadastrado para ser 
visualizado.
Para listar todos os contatos, a primeira linha do código, 
do exemplo acima, não deve ter o identificador do contato. Crie 
uma nova “Empty Activity” em seu projeto, com o nome de Lista_
Contatos e insira o código apresentado anteriormente em um 
botão, da seguinte forma:
40 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Imagem 4.31 – Visualizando o primeiro contato da lista de contatos
Fonte: Elaborada pela autoria (2023).
Executando o aplicativo, temos o seguinte resultado:
Imagem 4.32 – Resultado do exemplo
Fonte: Elaborada pela autoria (2023).
41PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
ACTION_PICK
Diferente do “ACTION_VIEW”, que apenas permite a 
visualização dos contatos, como mostrado no tópico anterior, o 
“ACTION_PICK”, além de permitir a visualização desses, permite 
também que o usuário selecione um deles e, ao fazer isso, a 
atividade “lista de contatos” é fechada e o contato selecionado é 
retornado para a atividade anterior. 
Para o melhor entendimento de como o “ACTION_PICK” 
funciona, siga as seguintes orientações: crie uma nova tela (Empty 
Activity) em seu projeto, e dê a ela o nome de Tela2. Dentro dela, 
crie um botão (button1) e o atribua a função “Listener” - para que, 
ao ser clicado, abra a tela de contatos para que o usuário possa 
selecionar um deles. 
O código xml fica desta forma:
Imagem 4.33 – Código xml do layout da tela2
Fonte: Elaborada pela autoria (2023).
42 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
O código java deve ser como mostrado na seguinte 
imagem:
Imagem 4.34 – Código java da tela2
Fonte: Elaborada pela autoria (2023).
Repare que, diferente do que aconteceu no exemplo 
utilizando o “ACTION_VIEW”, nesse caso não se indica o número do 
contato a ser exibido (linha 23). Ao ser executado, o aplicativo deve 
se comportar da maneira apresentada a seguir:
43PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Imagem 4.35 – Resultado da utilização do ACTION_PIC
Fonte: Elaborada pela autoria (2023).
ACTION_CALL
Outra ação importante é o “Intent.ACTION_CALL”, 
responsável por fazer ligações telefônicas para um contato 
especificado. Sua utilização deve ser como exemplificado a seguir. 
EXEMPLO: Uri telefone = Uri.parse(“tel:99999999”); Intent i 
= new Intent(Intent.ACTION_CALL, telefone); startActivity(i);
 Para o melhor entendimento de como o “ACTION_PICK” 
funciona, verifique as seguintes afirmações: crie uma nova tela 
(Empty Activity) em seu projeto e dê a ela o nome de Tela3. Dentro 
dela, crie um botão (button1) e o atribua a função “Listener”, para 
que, ao ser clicado, possa iniciar a atividade de “fazer chamada 
telefônica”.
44 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
O código xml fica desta forma:
Imagem 4.36 – Código xml do layout da tela3
Fonte: Elaborada pela autoria (2023).
O código java deve ser como mostrado a seguir:
Imagem 4.37 – Código java para o exemplo
Fonte: Elaborada pela autoria (2023).
45PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Ao ser executado, o aplicativo deve se comportar da 
maneira apresentada na seguinte imagem:
Imagem 4.38 – Resultado para a utilização de ACTION_CALL
Fonte: Elaborada pela autoria (2023).
SAIBA MAIS
Para conhecer outras ações que podem ser 
executadas pelo objeto Intent, acesse o QR code . 
http://developer.android.com/reference/android/content/Intent.html 
46 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
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 tudo o que vimos. 
Aqui, você aprendeu a invocar ações dos recursos 
residentes no sistema operacional Android. 
Esperamos que tenha aproveitado ao máximo 
todo o conteúdo apresentado.
47PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Layout de tela
OBJETIVO
Ao término deste capítulo, você será capaz de 
entender como são os layouts de telas, quais as 
relevâncias dos componentes, dos atributos e 
como combinar os layouts. E então? Motivado para 
desenvolver essa competência? Então vamos lá. 
Bom estudo!
Entendendo o layout de tela
Como visto, sempre que uma tela (classe atividade) 
é definida, é necessário também definir o arquivo xml que 
corresponde ao seu layout. Durante todo o material, foi utilizado 
o layout para facilitar a compreensão e a disposição simples que 
ele permite. Este tópico trata dos tipos de layout mais importantes 
permitidos pelo sistema Android, para se configurar uma aplicação. 
São eles: FrameLayout, LinearLayout e TableLayout.
IMPORTANTE
Nas aplicações atuais, um layout bem definido 
é muito importante para chamar a atenção do 
usuário. Por isso, além de ter um código que 
funcione corretamente (sem erros e com as regras 
de negócio bem determinadas), o desenvolvedor 
não pode esquecer de tratar o layout do aplicativo 
como algo essencial para o sucesso do produto.
FrameLayout
Esse é o tipo mais comum de layout, em que o 
componente sempre é posicionado no canto superioresquerdo 
da tela e, caso exista mais de um componente, um sobrepõe o 
outro. Dependendo do tamanho (propriedades altura e largura), 
definidos pelo usuário, o mesmo pode preencher toda a tela. Crie 
um novo app, chamado “AppLayout1_U4”, com uma Empty Activity. 
48 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Dentro do arquivo xml que define o layout da activity, insira o 
seguinte código, como mostra a imagem a seguir:
Imagem 4.39 – Código do exemplo
Fonte: Elaborada pela autoria (2023).
Depois, salve o arquivo, execute a aplicação e verifique o 
resultado. Ele deve se parecer com o da seguinte imagem:
49PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Imagem 4.40 – Frame Layout
Fonte: Elaborada pela autoria (2023).
Note que a componente imagem sobrepôs o componente 
texto e que a cor de fundo do layout foi definida pelo atributo 
“Android:background” (linha 6, da imagem 4.39) que, para esse 
caso, recebeu o valor “@ Android:color/holo_orange_light”. Outro 
item importante a ser notado está na linha 20, da imagem 4.39: 
a propriedade “src” define a imagem a ser usada. Essa imagem 
deve estar definida na pasta res-> mipmap, como destacado na 
sequência:
50 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Imagem 4.41 – Local onde devem ser armazenadas as imagens que podem ser utilizadas no 
aplicativo
Fonte: Elaborada pela autoria (2023).
À primeira vista, pode parecer que esse tipo de layout não 
tenha muita utilidade, porém, se alterarmos um pouco o tamanho 
e a disposição dos componentes da tela, você vai perceber que 
ele pode ser bastante útil. Veja só nesse exemplo: crie uma nova 
Empty Activity na sua aplicação e insira o código abaixo (imagem 
4.42) no arquivo xml que define o layout da tela.
51PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Imagem 4.42 – Exemplo da utilização do FrameLayout
Fonte: Elaborada pela autoria (2023).
Depois de salvar e executar essa Activity, temos o seguinte 
resultado:
52 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Imagem 4.43 – Resultado do uso de FrameLayout
Fonte: Elaborada pela autoria (2023).
Antes de passar para o próximo tipo de layout, é necessário 
dar destaque à “linha 14” do código xml acima, o qual determina a 
imagem a ser usada: “Android_logo1”. Essa imagem não vem com 
a IDE Android Studio, como acontece com algumas outras e, para 
utilizá-la, é necessário inseri-la na pasta “res->mipmap”, da seguinte 
forma: 1 - Grave a imagem que deseja inserir no seu aplicativo em 
algum local na sua máquina (de preferência no formato png); 2 - 
Clique sobre a imagem, com o botão direito do mouse e selecione 
a opção copiar; 3 - Clique sobre a pasta “mipmap”, com o botão 
direito do mouse e selecione a opção colar. Para inserir a imagem 
na tela use o código xml “Android:src:@ mipmap/Android_logo1”, a 
destacar que “Android_logo1” é o nome da imagem.
53PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
LinearLayout
Esse tipo de layout é utilizado para organizar os 
componentes na vertical ou na horizontal. A orientação dos 
componentes é definida pelo atributo “Android:orientation”, o qual 
pode ter o valor “horizontal” ou “vertical”. Crie uma nova Empty 
Activity em sua aplicação e escreva o seguinte código no arquivo 
xml correspondente ao layout desta tela:
Imagem 4.44 – Exemplo do uso de LinearLayout (vertical)
Fonte: Elaborada pela autoria (2023).
Depois, salve e execute a aplicação. O resultado deve ser 
como apresentado a seguir:
54 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Imagem 4.45 – Resultado do exemplo do uso de LinearLayout (vertical)
Fonte: Elaborada pela autoria (2023).
Repare que a componente imagem foi posicionada abaixo 
(orientação vertical) do componente texto, a cor (imagem) de fundo 
do layout foi definida pelo atributo “Android:background” que, para 
este caso, recebeu o valor “@drawable/ic_launcher_background” 
e a cor do texto foi definida pelo “atributo Android:textColor”, 
como sendo branca. Alterando a orientação do LinearLayout para 
horizontal, teremos o seguinte resultado:
55PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Imagem 4.46 – Resultado do exemplo do uso de LinearLayout (vertical)
Fonte: Elaborada pela autoria (2023).
Relevância dos componentes
Dentro do layout do tipo LinearLayout, você pode 
determinar o espaço que cada componente deve ocupar na tela 
pela importância definida para ele. O atributo responsável por 
definir essa característica de relevância é o “Android:layout_weight” 
que, por padrão, vale zero para todos os componentes. Nota-
se, então, que, por padrão, todos os componentes possuem 
relevâncias idênticas, porém, essa propriedade pode ser alterada 
para valores inteiros maiores que zero. Quanto maior o número 
definido para esse atributo, maior o espaço que o componente 
ocupará na tela do aplicativo.
56 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Imagine que você queira diferenciar o espaço ocupado 
pelos componentes de uma tela cujo projeto de layout é 
apresentado na próxima imagem:
Imagem 4.47 – Projeto de layout do exemplo
Fonte: Elaborada pela autoria (2023).
O código xml da tela será apresentado, conforme a imagem 
a seguir:
57PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Imagem 4.48 – Código xml do layout da tela do exemplo
Fonte: Elaborada pela autoria (2023).
É importante destacar aqui algumas linhas de código da 
imagem 4.48: 
 • Na linha 5 e 6, foram definidos os espaçamentos dos 
componentes, para que eles não fiquem “grudados” às 
margens esquerda e direita da tela do dispositivo; 
 • Nas linhas 11, 15 e 21, foram definidos os “textos” que 
aparecem na caixa de texto, a informar o que o usuário 
deve digitar. 
58 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
• Na linha 19, é definido que a terceira caixa de texto deve 
ocupar maior espaço que os demais componentes da tela; 
• Na linha 26, é definido que o componente botão deve 
ficar alinhado à direita. Salve e execute este código. O resultado 
deve ser o apresentado na próxima imagem:
Imagem 4.49 – Resultado do exemplo
Fonte: Elaborada pela autoria (2023).
59PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
TableLayout
Esse tipo de layout é utilizado para organizar os 
componentes em linhas e colunas, simulando uma tabela. É o tipo 
ideal de layout para construir formulários. Cada linha da tabela 
é definida pela tag “TableRow” e, dentro dela, cada componente 
incluído é considerado uma coluna.
Crie uma nova Empty Activity em seu projeto. Queremos, 
nesse caso, que a tela tenha o seguinte layout:
Imagem 4.50 – Protótipo de tela para o uso de TableLayout
Fonte: Elaborada pela autoria (2023).
Na imagem 4.50, temos uma tabela com duas linhas e duas 
colunas. O seguinte código xml, pode ser usado para resolver essa 
questão:
60 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Imagem 5.51 – Código xml para o exemplo da utilização do FrameLayout
Fonte: Acervo da autoria (2023).
Note que as linhas 9 e 10 (imagem 5.51) declaram as 
células da primeira linha da tabela, e as linhas 13 e 14, as células 
da segunda linha da tabela. O resultado do código anterior pode 
ser visualizado na próxima imagem:
Imagem 5.52 – Resultado do exemplo do uso do FrameLayout
Fonte: Elaborada pela autoria (2023).
61PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Atributo StretchColluns
Muitas vezes, é necessário expandir as colunas para forçar 
o preenchimento de toda a tela do dispositivo. Nesses casos, 
utiliza-se o atributo “StrechColluns”. Crie uma nova Empty Activity 
em seu projeto e para o seu código xml relativo ao layout, copie o 
código da imagem a seguir:
Imagem 4.53 - Exemplo do uso do atributo StretchColluns no TableLayout
Fonte: Acervo da autoria (2023).
62 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Repare que o atributo “Android:stretchColumns” (linha 
7, imagem 5.53) define que a primeira coluna deve se expandir 
para que a “tabela” preencha toda a largura da tela. O atributo 
“Android:layout_gravity” (linha 15) está sendo utilizado apenas 
na “linha 1 – coluna2” para forçar o conteúdo dessa célula a 
ficar alinhado à direita. Os atributos “background” são usados 
nas linhas 12, 14, 20 e 23 para permitir melhor visualização do 
comportamento das células da tabela, como mostra a seguinte 
imagem:
Imagem 4.54 – Resultado do exemplo do uso do atributo StretchColluns no TableLayout
Fonte: Acervo da autoria (2023).
63PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Para melhor fixação dos conhecimentos, acompanhe o 
exemplo a seguir. Imagine que você precisa montar uma tela com 
as seguintes características: 
 • Na tela deve constar uma tabela com 3 linhas e 2 
colunas: a primeira linha deve conter, na primeira 
coluna, um label “Digite seu login”; 
 • Na segunda coluna, uma caixa de texto para que o 
usuário digite o login. 
A segunda linha deve conter: 
 • Na primeira coluna, um label “Digite sua senha”. 
 • Na segunda coluna, uma caixa de texto para que o 
usuário digite a senha. 
A terceira linha deve conter: 
 • Na primeira coluna, um botão “Validar”. 
 • Na segunda coluna, um botão “Cancelar”. O código xml 
para o layout deve ser parecido com o apresentado na 
próxima imagem:
64 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Imagem 4.55 – Código xml para o layout da tela do exemplo
 
Fonte: Elaborada pela autoria (2023).
65PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Por fim, salve e execute essa activity. O resultado deve ser 
o seguinte:
Imagem 4.56 – Resultado do código xml para o layout da tela do exemplo
Fonte: Elaborada pela autoria (2023). 
IMPORTANTE
Verifique o que precisa ser alterado no código 
ou na estrutura dos componentes da activity 
acima (imagem 4.56), para que a componente 
que apresenta a senha mostre apenas asteriscos 
quando o usuário nela digitar.
Atributo ShrinkColluns
Em outros casos, as colunas precisam ser contraídas para 
que o conteúdo delas caiba na tela. O código xml (imagem 4.57) 
apresenta o caso em que uma célula possui um conteúdo muito 
grande e precisa ser adaptado à tela.
66 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Imagem 4.57 – Exemplo do uso do atributo ShrinkColluns
Fonte: Elaborada pela autoria (2023).
O resultado deve ser como na próxima imagem:
67PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Imagem 4.58 – Resultado do exemplo do uso do atributo ShrinkColluns
Fonte: Elaborada pela autoria (2023).
Combinando layouts
Quando necessário, pode-se combinar os tipos de 
layouts na mesma tela. Verifique o exemplo a seguir em que são 
combinados “TableLayout” e “LinearLayout”:
Imagem 4.59 – Código xml que combina TableLayout e LinearLayout
68 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
 
Fonte: Elaborada pela autoria (2023).
O resultado é mostrado a seguir:
Imagem 4.60 – Resultado do código xml que combina TableLayout e LinearLayout
Fonte: Elaborada pela autoria (2023).
69PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
Como você deve ter percebido, é possível fazer muito 
mais com os apps Android. Não deixe de verificar as referências 
bibliográficas para aprender mais. Isso é só o começo, e 
a aprendizagem não pode parar! Muito obrigado por ter 
acompanhado todo o processo até aqui. Sucesso para você!
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 tudo o que vimos. 
Você deve ter aprendido a projetar e a desenhar 
telas para aplicativos móveis, aplicando-lhes 
técnicas de usabilidade e recursos disponíveis 
no sistema Android, por meio da linguagem Java 
Mobile. Esperamos que tenha aproveitado ao 
máximo todo o conteúdo apresentado.
70 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 4
RE
FE
RÊ
N
CI
A
S
CLARO, D.; SOBRAL, J. Programação em JAVA. Florianópolis: 
Copyleft Pearson Education, 2008. 
CORDEIRO, F. Android aprendiz. [S. l.]: AndroidPro, 2017. 
CORDEIRO, F. Android studio. 3. ed. [S. l.]: AndroidPro, 2016.
MORIMOTO, C. Smartphones, Guia Prático. Hardware, 
2009. Disponível em: https://www.hardware.com.br/livros/
smartphones/. Acesso em: 08 dez. 2023.
https://www.hardware.com.br/livros/smartphones/
https://www.hardware.com.br/livros/smartphones/
	Tratamento de eventos
	Definindo o protótipo da aplicação
	Implementando a aplicação
	Preparando a tela principal
	Preparando a tela2
	Preparando a tela3
	Capturando resultados de uma atividade
	Preparando as telas da aplicação
	Capturando a seleção do usuário
	Retornando o item selecionado
	Chamando ações do sistema Android
	ACTION_VIEW
	ACTION_PICK
	ACTION_CALL
	Layout de tela
	Entendendo o layout de tela
	FrameLayout
	LinearLayout
	Relevância dos componentes
	TableLayout
	Atributo StretchColluns
	Atributo ShrinkColluns
	Combinando layouts