Programação para Dispositivos Móveis · ambiente de desenvolvimento integrado e se refere a ferramentas de desenvolvimento como Eclipse ou Android Studio, por exemplo) e instalar

Curso Técnico em Desenvolvimento de Sistemas

Educação a Distância

2018

2018

Programação para Dispositivos Móveis

Gilson de Oliveira

EXPEDIENTE

Professor Autor Gilson de Oliveira

Design Educacional

Deyvid Souza Nascimento Renata Marques de Otero

Revisão de Língua Portuguesa

Letícia Garcia

Diagramação Jailson Miranda

Coordenação

Anderson Elias

Coordenação Executiva George Bento Catunda

Terezinha Mônica Sinício Beltrão

Coordenação Geral Paulo Fernando de Vasconcelos Dutra

Conteúdo produzido para os Cursos Técnicos da Secretaria Executiva de Educação Profissional de Pernambuco, em convênio com o Ministério da Educação

(Rede e-Tec Brasil).

Janeiro, 2017

Dados Internacionais de Catalogação na Publicação (CIP) de acordo com ISDB

O48p Oliveira, Gilson de.

Programação para Dispositivos Móveis: Curso Técnico em Desenvolvimento de Sistemas: Educação a distância / Gilson de Oliveira. – Recife: Secretaria Executiva de Educação Profissional de Pernambuco, 2018.

91 p.: il. Inclui referências bibliográficas. Material produzido em dezembro de 2016 através de convênio com o Ministério da

Educação (Rede e-Tec Brasil) e a Secretaria de Educação de Pernambuco. 1. Engenharia de Software. 2. Dispositivos Móveis. I. Oliveira, Gilson de. II. Título.

CDU – 02:141:005.6

Elaborado por Hugo Carlos Cavalcanti | CRB-4 2129

Índice para catálogo sistemático:

1. Engenharia de software

Sumário

Introdução .............................................................................................................................................. 6

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

1.1 Activity........................................................................................................................................................ 8

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

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

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

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

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

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

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

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

2.3 Solicitando ao google maps que exiba um local específico do mapa ...................................................... 28

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

2.5 Retornando resultados de uma activity para outra através do método startActivityForResult ............. 30

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

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

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

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

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

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

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

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

3.7 Resumo ..................................................................................................................................................... 47

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

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

4.2 Arquivo com as mensagens da aplicação ................................................................................................. 50

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

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

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

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

4.7 Resumo ..................................................................................................................................................... 56

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

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

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

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

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

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

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

5.7 ProgressDialog.......................................................................................................................................... 71

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

5.9 Resumo ..................................................................................................................................................... 73

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

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

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

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

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

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

6.6 Resumo ..................................................................................................................................................... 78

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

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

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

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

7.4 Assinando a aplicação para publicá-la no Google Play ............................................................................ 85

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

Conclusão ............................................................................................................................................. 89

Referências ........................................................................................................................................... 90

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

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

6

Introdução

Neste caderno vamos aprender mais sobre o sistema operacional Android, suas

principais classes, características e comportamentos. A plataforma Android foi escolhida neste curso

por ser bastante difundida, madura, robusta e acessível, tanto para desenvolver quanto para um

usuário que deseja adquirir um equipamento que pode ser um tablet ou smartphone. Para iniciar o

desenvolvimento, não existem muitas restrições, não é preciso de um equipamento específico,

licença ou certificado de desenvolvimento, basta ter um computador (atendendo os requisitos

mínimos de processamento especificados pela ferramenta de desenvolvimento que você deseja

utilizar), fazer o download gratuito de uma IDE (Integrated Development Environment, que significa

ambiente de desenvolvimento integrado e se refere a ferramentas de desenvolvimento como

Eclipse ou Android Studio, por exemplo) e instalar o SDK (Software Development Kit) Android.

Dentre as três principais plataformas de desenvolvimento móvel, o Android é uma das

mais acessíveis no que diz respeito à aquisição de um exemplar. Existem smartphones de todos os

preços, os mais baratos custam em torno de 250,00 reais e os mais caros podem custar até milhares

de reais, por exemplo, os modelos top de linha da Samsung podem custar cerca de R$ 6.000. Tendo

um aparelho é possível você instalar e testar o seu aplicativo no próprio dispositivo e observar o seu

comportamento e layout, isso é bastante interessante, mas caso você não possua um smartphone,

você pode fazer uso do emulador que simula a utilização de um dispositivo no seu próprio

computador.

O Android é o sistema operacional (SO) mais utilizado no mundo. Em 2014, a GOOGLE

anunciou que existem mais de 1 bilhão de usuários Android ativos. Apesar de ter sido criado pela

GOOGLE, o Android é regido por uma licença de código aberto, ou seja, é permitido que você baixe

o código do sistema operacional Android e o modifique da maneira que você desejar. Essa prática

de modificar o SO Android é bastante comum e utilizada pela maioria das empresas. Dessa forma,

há uma combinação do código aberto disponibilizado com o código privado desenvolvido pela

empresa. Essas modificações no SO feitas pela empresa vão desde melhorias na interface, com

aumento de nitidez das imagens, brilho, performance, até a incorporação de aplicativos nativos da

empresa.

Falando em desenvolvimento de aplicativos para a plataforma Android de forma

autônoma, o GOOGLE possui a GOOGLE PLAY, que é a loja da empresa para a disponibilização e

venda de aplicativos para a plataforma Android. Caso você crie o seu próprio aplicativo, pode

7

vendê-lo na loja da GOOGLE ou mesmo disponibilizá-lo de forma gratuita e tentar ganhar dinheiro

através de anúncios e propagandas que a GOOGLE embute no seu aplicativo, caso você permita.

Existem vários casos de sucesso de pessoas jovens que criaram aplicativos, colocaram na

loja e ficaram ricas. O criador do Ant Smasher já teve o seu jogo baixado por mais de 30 milhões de

pessoas. O aplicativo é gratuito, mas rende mais de 3 milhões de dólares por ano apenas com

anúncios. O criador de Flappy Bird, um jogo bem simples, chegou a, no início de 2014, 50 mil

dólares por dia. Por que você não pode ser uma dessas pessoas?

Aprender uma linguagem de programação exige dedicação, persistência e curiosidade.

Dedicação e persistência para estudar o material disponibilizado e fazer os exercícios propostos,

curiosidade para ir atrás de novas informações, notícias, outros materiais e novos exercícios.

Quando terminar de estudar o material do curso, busque novos materiais, tutoriais e outros

exemplos em livros e na internet. O ser humano aprende por repetição, quanto mais você praticar,

mais você vai assimilar o conteúdo. A cada exemplo, tente entendê-lo e tente você mesmo fazer e

não fique apenas como espectador, dessa forma você criará suas próprias soluções.

Nos próximos capítulos vamos falar de algumas das classes mais importantes utilizadas

para o desenvolvimento em Android. Com relação à ferramenta de desenvolvimento (também

chamada tecnicamente de IDE - Integrated Development Environment) você pode tanto usar o

Eclipse (ADT – Android Development Tools) ou o Android Studio (mais recomendo).

Comercialmente, o Android Studio vem sendo cada vez mais usado, principalmente para novos

projetos. Para fazer o download do Android Studio, basta acessar o site

https://developer.android.com/studio/index.html?hl=pt-br e fazer o download da versão mais

recente. Caso você ainda não tenha o SDK Android, deve baixar o Android Studio com o SDK. Caso já

tenha, basta baixar apenas o Android Studio.

E então, vamos começar a nos divertir?

https://developer.android.com/studio/index.html?hl=pt-br

Competência 01

8

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

de Activity

Vamos aprender neste capítulo o conceito de activity, como funciona o seu ciclo de vida,

como mudar de uma activity para outra. Aprenderemos também como trafegar informações entre

as telas da sua aplicação e falaremos da ListActivity, que é um tipo específico de activity.

Vamos começar!

1.1 Activity

Uma Activity é uma classe que herda de Android.app.Activity ou alguma subclasse

desta. Em geral, toda tela de uma aplicação em Android está associada a uma Activity e esta é

responsável por tratar todos os seus eventos como cliques de botão, seleção de checkbox, cliques

no menu e mudanças de tela, por exemplo.

Toda Activity implementa obrigatoriamente o método onCreate(bundle), responsável

por inicializar os elementos necessários para que a tela seja exibida para o usuário. Para isso, o

método setContentView(view) é chamado especificando-se a view que contém os elementos da

tela. Além disso, toda Activity deve ser declarada no arquivo AndroidManifest.xml da seguinte

forma:

<activity Android:name:”.MinhaActivity” />

Esse “.” antes do nome da sua Activity indica que ela está no mesmo pacote do projeto,

caso ela estivesse em um pacote diferente, o nome do pacote deveria ser especificado. Lembre-se

de escrever o nome da Activity corretamente, pois o compilador é case sensitive, ou seja, ele

diferencia as letras maiúsculas das minúsculas, dessa forma para ele “MinhaActivity” é diferente de

“minhaActivity”. Para ter certeza de que o nome e o pacote foram especificados corretamente,

segure a tecla control do seu teclado e passe o mouse em cima do nome da sua Activity, se o texto

ficar “clicável” indica que você pode chegar até a sua Activity apenas clicando, pois ela foi

encontrada no caminho especificado.

Bom, dito isso, lembre-se de que quando você desejar criar uma nova tela na sua

aplicação Android você precisará criar também uma nova Activity e esta necessariamente deverá

ser declarada no AndroidManifest.xml. Ela vai controlar os eventos e elementos da tela, que é

Competência 01

9

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

como parâmetro uma referência para um arquivo XML que contém os elementos da sua interface.

1.2 Ciclo de vida de uma Activity

É bastante importante você entender o ciclo de vida de uma Activity para saber em qual

estado ela se encontra e para você poder controlar o comportamento da sua aplicação. Tenha em

mente o seguinte: quem cuida da execução do fluxo do ciclo de vida é o sistema operacional

Android, mas você pode customizar os estados (executando, temporariamente interrompida em

segundo plano e completamente destruída), por exemplo.

Vamos ver um exemplo prático da utilização e da importância do conhecimento e do

uso desses estados. Imagine que você tenha desenvolvido um jogo espetacular para Android e

enquanto o usuário está jogando ele recebe uma ligação, o que vai acontecer com o jogo? Bom, o

sistema operacional vai interromper o jogo e colocá-lo em segundo plano para que o usuário possa

atender a ligação. Ao encerrar a ligação a grande pergunta que resta é: o que irá acontecer com o

jogo? O jogo vai estar pausado? O jogo foi salvo? Bom, isso vai depender do que foi especificado

por você, desenvolvedor. O Android fornece toda a infraestrutura necessária para isso, basta você

entender o ciclo de vida da Activity.

Competência 01

10

A figura abaixo (figura 1) ilustra o fluxo do ciclo de vida de uma Activity e seus possíveis

estados.

Figura 1 - Ciclo de vida de uma activity

Fonte: O próprio autor. Descrição: A figura mostra todas as fases do ciclo de vida de uma aplicação Android. Quando uma activity é iniciada o seu ciclo de vida tem início e o método onCreate é executado, em seguida é executado o onStart e o onResume. Caso outra activity seja iniciada, a atual é pausada, então, é executado o método onPause. Se a activity anterior voltar a executar, ela chamará novamente o onResume, caso contrário, é chamado o método onStop e em seguida pode ser chamado o onDestroy, que encerra a activity ou pode ser chamado o onRestart , se a activity voltar a executar ou caso ela tenha ido para segundo plano no onStop e for encerrada pelo SO. No caso dela voltar a ser exibida, o método onCreate é chamado novamente.

Preste bastante atenção, pois agora iremos explicar cada um dos métodos que se

encontram no ciclo de vida de uma activity. É importante que você leia a descrição do método e vá

acompanhando o fluxo na figura 1.

Competência 01

11

onCreate(bundle)

É um método obrigatório, por isso deve estar presente em toda activity e é executado apenas uma vez. Ele é responsável por criar a activity e chamar o método setContentView(view) que faz a associação entre a activity e um arquivo de interface específico (XML) que contém os elementos da tela que serão exibidos para o usuário. Logo após a execução do onCreate(bundle) é chamado o método onStart().

onStart() Esse método é chamado após a activity ser criada, bem como a sua view, ou seja, após o método onCreate(bundle). Sua view está prestes a ficar visível. Como mostrado no fluxo acima, esse método também é chamado sempre após o onRestart().

onRestart() Esse método é chamado caso sua activity tenha sido parada temporariamente e esteja sendo iniciada novamente, então o Android chama o onRestart() que logo em seguida chama o onStart().

onResume() Esse método é chamado quando a activity já está executando e está pronta pra interagir com o usuário.

onPause() Caso o celular entre em modo de espera, hiberne, receba uma ligação ou a aplicação seja colocada em background o método onPause() é chamado. Dessa forma, o desenvolvedor pode salvar algum estado ou informação que está sendo usada pela aplicação.

onStop() É chamado quando a activity está sendo encerrada e já não está mais visível para o usuário. Isso pode ocorrer quando a aplicação muda de uma activity pra outra, num comportamento de transição de telas.

onDestroy() Encerra a execução de uma activity. O sistema operacional libera os recursos alocados pela activity como valores de atributos e demais recursos.

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

Descrição: Tabela informando os métodos do ciclo de vida de uma Activity, bem como a sua descrição de quando ocorre.

A seguir mostrarei um exemplo do código de uma activity que implementa os métodos:

onCreate(bundle), onStart(), onRestart() e onResume() do ciclo de vida que mencionamos

anteriormente. Recomendo seguir o exemplo e implementar todos os métodos. Dessa forma, você

pode fazer seus próprios testes: colocar a aplicação em background, ligar para o seu celular,

encerrar a aplicação e ir vendo os métodos que são chamados através das mensagens de log que

serão exibidas na janela do LogCat. Para isso, você pode criar um projeto Android simples e

executá-lo usando o emulador do Android ou o seu próprio celular.

Competência 01

12

public class MainActivity extends Activity {

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

Log.i(getLocalClassName(), "onCreate()");

TextView olaMundo = new TextView(this);

olaMundo.setText("Olá mundo! :)");

setContentView(olaMundo);

}

@Override

protected void onStart(){

super.onStart();

Log.i(getLocalClassName(), "onStart()");

}

@Override

protected void onRestart(){

super.onRestart();

Log.i(getLocalClassName(), "onRestart()");

}

@Override

protected void onResume(){

super.onResume();

Log.i(getLocalClassName(), "onResume()");

}

}

Competência 01

13

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

Figura 2 - Impressão de logs no LogCat

Fonte: O autor. Descrição: Está sendo mostrado um printscreen das informações exibidas no LogCat mostrando quais métodos foram chamados a partir da exibição de uma Activity. No caso, está sendo exibido um print escrito onCreate(), onStart() e onResume().

Note que é exibido o nome da activity (getLocalClassName()) e a mensagem que foi

especificada no segundo parâmetro, no caso o nome do método que está sendo chamado. O trecho

mais importante é o final, no caso:

…MainActivity: onCreate()

…MainActivity: onStart()

...MainActivity: onResume()

Quando se coloca em background, apertando o botão da casinha (home) do Android e

depois a se coloca em evidência novamente, é mostrado o seguinte:

...MainActivity: onRestart()

...MainActivity: onStart()

...onResume()

Note que o onCreate(bundle), como havíamos falado anteriormente, é chamado apenas

uma vez. No meu exemplo não inclui os métodos onPause(), onStop() e onDestroy(), coloque-os no

seu exemplo e me diga quais métodos foram chamados quando você clicou no botão home

(símbolo da casinha) e quando você encerrou a aplicação. Perceba que você apenas implementou

os métodos e não está chamando eles em lugar algum. Quem faz essa chamada é o próprio sistema

operacional Android.

Entender o ciclo de vida de uma activity é fundamental para você dominar o

desenvolvimento de aplicações Android. O conhecimento e domínio desses métodos são bastante

importantes principalmente para o desenvolvimento de jogos. Imagine que você está jogando e

recebe uma ligação ou a bateria acaba e o jogo não foi salvo e você tem apenas uma vida ou está

Competência 01

14

com o progresso bastante avançado, então o ideal seria que o jogo fosse salvo ao ser interrompido

ou mesmo pausado para que o usuário não seja prejudicado com interrupções externas e que

fogem do controle do usuário, mas não do desenvolvedor.

1.3 Navegação entre activities

Até agora vimos alguns conceitos do que é uma activity e para que ela é utilizada bem

como o seu ciclo de vida. Agora vamos criar outras activities e aprender como navegar de uma para

outra, tendo em mente que cada activity representa uma tela e a maioria dos aplicativos que

utilizamos possui um conjunto de telas diferentes, então para cada tela será criada uma nova

activity.

Para navegar entre activities (mudar de tela) você pode utilizar dois métodos diferentes:

ou você utiliza o startActivity(intent) ou o startActivityForResult(intent, codigo). Ambos utilizam uma

instância da classe Intent. Intent significa intenção, no nosso caso a nossa intenção é mudar de

activity, ou seja, navegar de uma tela para outra. Veremos com detalhes essa classe Intent no nosso

material.

O método startActivity simplesmente faz a mudança de uma tela para outra sem deixar

nenhum vínculo com a tela anterior, já o startActivityForResult passa um código como parâmetro

para que a segunda Activity saiba de onde veio a informação e possa retornar para esta uma outra

informação. Esse segundo método é usado quando a primeira tela precisa de um parâmetro da

segunda. Dessa forma, quando a segunda tela é encerrada, ela passa a informação para a tela que a

chamou.

1.3.1 Navegação simples de uma activity para outra

O código a seguir mostra como a partir de um clique de botão é possível abrir uma nova

tela (o botão ocupa a tela toda, mas não se preocupe com isso agora). Note que para isso você

precisa de uma segunda activity. Já que estamos navegando de uma tela para outra serão

necessárias duas activities para o exemplo. A primeira activity vamos chamar de MainActivity e a

segunda de SegundaTela.

Competência 01

15

Exemplo MainActivity

public class MainActivity extends Activity implements View.OnClickListener

{

@Override



Button olaMundo = new Button(this);

olaMundo.setText("Olá mundo! :)");

olaMundo.setOnClickListener(this);

setContentView(olaMundo);

}

public void onClick(View v) {

Intent tela2 = new Intent(this, SegundaTela.class);

startActivity(tela2);

}

}

Exemplo SegundaTela

public class SegundaTela extends Activity {



TextView tela2 = new TextView(this);

tela2.setText("Bem vindo a SegundaTela.");

setContentView(tela2);

}

}

Se você tiver essas duas activities criadas você vai conseguir rodar? Depende... Você

se lembrou de declarar essa sua nova activity no AndroidManifest.xml? Lembre-se de que toda nova

Competência 01

16

activity(tela) deve ser declarada no AndroidManisfest, caso você não faça isso o seu LogCat vai

exibir a seguinte mensagem de erro quando você clicar no botão na tentativa de mudar de tela:

FATAL EXCEPTION

Unable to find explicit activity class SegundaTela

have you declared this activity in your AndroidManifest.xml?

Perceba que ele exibe uma mensagem em inglês informando o porquê do erro,

traduzindo: “você declarou essa activity no seu AndroidManifest.xml?”. Para que isso não ocorra

adicione a seguinte linha no seu AndroidManifest.xml:

<activityAndroid:name=".SegundaTela" />

O que acontece com a primeira activity após a mudança para a segunda tela? Veja o que

foi impresso no LogCat a partir da implementação e impressão de log nos métodos do ciclo de vida

que aprendemos anteriormente. Implemente os métodos do ciclo de vida tanto para a primeira tela

quanto para a segunda e entenda o que acontece em ambas.

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

Agora já sabemos como navegar de uma tela para outra, mas como enviar uma ou mais

informações da primeira tela para a segunda? Para isso, usaremos uma classe chamada Bundle que

é similar a uma HashTable (estrutura de dados do tipo chave valor). Ela faz uso do método

putString(chave, valor) para configurar as informações que serão passadas em formato de texto

para a próxima tela.

Agora faremos uma pequena modificação no exemplo anterior para ilustrar a passagem

de informações entre as telas (o código a seguir faz parte do conteúdo da classe MainActivity).



Bundle informacoes = new Bundle();

informacoes.putString("cargo","Professor");

informacoes.putString("nome","Gilson");

tela2.putExtras(informacoes);


}

Competência 01

17

No nosso exemplo utilizamos o método putString, mas a classe Bundle possui outras

opções caso você queira passar outro tipo primitivo como putBoolean, putChar, punInt, dentre

outras. Para obter a lista completa basta consultar o javadoc.

Já sabemos como passar as informações, agora precisamos saber como resgatá-las na

outra tela. Novamente vamos alterar o código que havíamos criado (o código a seguir faz parte do

conteúdo da classe SegundaTela).



TextView tela2 = new TextView(this);

Intent it = getIntent();

String cargo = "", nome = "";

if(it != null){

Bundle informacoes = it.getExtras();

if(informacoes != null){

cargo = informacoes.getString("cargo");

nome = informacoes.getString("nome");

}

}

tela2.setText("Bem vindo " + cargo + " " + nome);

setContentView(tela2);

}

Note que no onClick do botão da primeira tela (MainActivity) nós passamos o Intent

(chamado tela2) com as informações que desejamos transferir. Como o parâmetro do startActivity e

no onCreate da segunda tela (SegundaTela), nós resgatamos esse mesmo Intent (tela2) e extraímos

as informações que foram passadas através da chave “cargo” e “nome”, basicamente, foi isso que

fizemos.

Em toda linguagem de programação existem diferentes formas de se fazer a mesma

coisa, vai depender do seu conhecimento e da flexibilidade da mesma. Também poderíamos passar

as informações da seguinte forma:

Competência 01

18



tela2.putExtra("cargo", "Professor");

tela2.putExtra("nome","Gilson");


}

Veja que no exemplo acima nós omitimos a utilização Bundle e colocamos os

parâmetros diretamente no Intent. Da mesma maneira, para recuperar essas informações na

próxima tela, podemos novamente omitir a utilização da classe Bundle e fazer o seguinte:

cargo = it.getStringExtra("cargo");

nome = it.getStringExtra("nome");

1.4 ListActivity – uma activity diferente

A classe Activity é uma classe básica e simples que permite uma alta customização,

contudo existem outros tipos de Activities que são um pouco mais complexas, pois já apresentam

alguns comportamentos implícitos, como é o caso da classe ListActivity. Como o próprio nome já diz

é uma Activity utilizada para exibir uma lista de itens na vertical.

Esse tipo de activity já apresenta internamente um componente do tipo ListView,

responsável por desenhar uma lista vertical com uma barra de rolagem, se necessário. Além da

presença desse componente, o método setContentView(view) é chamado automaticamente pela

ListActivity, dessa forma o programador não precisa se preocupar com a view que será mostrada e

sim com os elementos que irão preencher a lista.

Agora como fazemos para criar essa lista de elementos? Bom, para isso será necessário

criar um objeto que implemente a classe ListAdapter que faz a ligação entre o componente

(ListView) e os valores que você deseja exibir na sua lista.

É importante que você entenda que você poderia criar uma Activity e adicionar um

ListView, ou você poderia usar diretamente uma ListActivity. Criando uma ListActivity você não

precisa interagir diretamente com o ListView. A ListActivity proporciona ao programador novos

métodos com o objetivo de facilitar tanto a criação quanto a manipulação da lista. Ai você pergunta:

“Professor, eu preciso conhecer todos os tipos de activity?”, a minha resposta é “Não!”. O meu

objetivo é mostrar que existem outros tipos de Activity e com o passar do tempo e à medida em

Competência 01

19

que você for adquirindo experiência vai acabar conhecendo outras classes de Activity. O objetivo

dessas outras classes é justamente facilitar a manipulação e a utilização dos componentes do

Android.

Agora, vamos colocar a mão na massa, vamos criar uma classe que estende de

ListActivity, preencher um array (conjunto) de objetos e exibir na tela, conforme demonstrado a

seguir:

public class MainActivity extends ListActivity {

@Override



String[] lista = new String[]{"Item 01", "Item 02"};

ArrayAdapter<String> arrayAdapter = new ArrayAdapter<String>

(this, Android.R.layout.simple_list_item_1, lista);

setListAdapter(arrayAdapter);

}

@Override

protected void onListItemClick

(ListView, View, int position, long id){

super.onListItemClick

(listView, view, position, id);

String itemSelecionado =

this.getListAdapter().getItem(position).toString();

Toast.makeText(this, "Item selecionado -> " + itemSelecionado,

Toast.LENGTH_LONG).show();

}

}

O método onListItemClick é um método da ListActivity utilizado para facilitar a

manipulação do ListView. Sempre que o usuário clicar em um elemento da lista esse método é

chamado automaticamente permitindo ao programador identificar qual objeto foi selecionado. No

exemplo acima, sempre que o usuário clicar em um item da lista nós exibimos um alerta através do

Competência 01

20

método show()da classe Toast com a mensagem “Item selecionado -> Item 01”, por exemplo. Caso

essa lista funcionasse como um menu, nós poderíamos identificar qual elemento foi clicado e ter

uma ação associada a cada item ou poderia ser usada apenas como uma lista de dados informativa.

Atenção para o parâmetro Android.R.layout.simple_list_item_1, ele

representa um layout de lista padrão predefinido pelo Android. Os layouts predefinidos ajudam

bastante quando se quer utilizar um layout simples, contudo para layouts mais complexos e

personalizados é necessário que o próprio desenvolvedor crie de acordo com a sua necessidade.

No nosso último exemplo nós criamos uma ListActivity com dois itens: “Item 01” e

“Item 02”, já que foi dada a ideia de criar um menu com o ListView da ListActivity. Vamos lá!? Já

temos uma lista com dois itens e já implementamos o método onListItemClick, a tarefa é a seguinte:

se o usuário clicar no “Item 01” nós vamos iniciar nova activity chamada CicloDeVidaActivity que vai

conter o nosso primeiro exemplo desse capítulo. Será uma activity simples com todos os métodos

do ciclo de vida implementados. Já se o usuário clicar no “Item 02” nós vamos chamar a activity

ItemClicadoActivity que recebe a informação do item clicado.

Já que não vamos criar nenhum item novo, então eu não preciso mexer no método

onCreate, eu só vou mexer no método onListItemClick, porque a única coisa que eu vou fazer é ter

uma ação diferente dependendo do item que for clicado, ok? Então, o método seria modificado da

seguinte forma:

@Override

protected void onListItemClick

(ListView, View, int position, long id){

switch (position){

case 0:

startActivity(new Intent(this, CicloDeVidaActivity.class));

break;

case 1:

Intent = new Intent(this, ItemClicadoActivity.class);

intent.putExtra("itemClicado",

this.getListAdapter().getItem(position).toString());

startActivity(intent);

break;

}}

Competência 01

21

Perceba que para identificar qual item foi clicado eu usei o parâmetro “position”, esse

parâmetro informa a posição do item clicado. O primeiro item é representado pela posição de

índice 0, o segundo item é representado pela posição de índice 1 e assim por diante.

No próximo capítulo abordaremos o conceito de Intent e veremos mais exemplos da sua

utilização, pois essa talvez seja a classe mais importante do Android. Lembre-se de que ela já foi

citada brevemente neste capítulo. Quando precisamos navegar de uma tela para outra, nós criamos

um Intent e passamos a tela para qual desejamos navegar como parâmetro e chamamos o método

startActivity(Intent).

Competência 02

22

2.Competência 02 | Intent

Neste capítulo aprenderemos mais sobre a classe Intent, que para muitos é o coração do

Android. Intent significa intenção, representa uma ação que a aplicação deseja executar. No

capítulo anterior, a intenção que tínhamos era a de mudar de uma tela para outra, mas poderíamos

ter a intenção de abrir o browser do celular, fazer uma ligação, abrir o GOOGLE PLAY para instalar

um aplicativo, enviar uma mensagem para o SO ou mesmo exibir um endereço ou rota no GOOGLE

MAPS.

Agora, aprenderemos diversas utilidades da classe Intent, por isso fique atento e se tiver

mais curiosidade busque mais informações na internet sobre as diversas formas de se utilizar um

Intent. Vamos aprender algumas delas.

2.1 Abrindo o browser e acessando um site específico

O Android já possui diversas ações padrões que podem ser requisitas pelo

desenvolvedor a qualquer momento. Dentre elas está a abertura de uma página web. Então, o

programador dirá para o Android: “Você pode abrir essa página para mim?”. E ele, como já possui

essa tarefa mapeada pelo sistema operacional dirá: “Sim, você que manda!”.

Vamos ver um exemplo a seguir de como através do clique de um botão podemos abrir

o buscador do Google:


{

@Override



Button abrirBrowser = new Button(this);

abrirBrowser.setText("Abrir o google.com");

setContentView(abrirBrowser);

abrirBrowser.setOnClickListener(this);

}

Competência 02

23

@Override


Uri endereco = Uri.parse("http://www.google.com");

Intent it = new Intent(Intent.ACTION_VIEW, endereco);

startActivity(it);

}

}

No código acima nós temos uma Activity chamada MainActivity que implementa a

interface View.OnClickListener. No método onCreate da Activity nós criamos um botão chamado

abrir Browser com o texto “Abrir o google.com” e, ao clicá-lo, nós chamamos o método onClick da

interface View.OnClickListener que foi sobrescrito pela nossa activity. Nesse método nós

instanciamos um objeto da classe URI onde especificamos o endereço web que desejamos abrir,

então criamos um Intent para sinalizar a intenção de abrir essa página (http://www.google.com),

por isso passamos o URI com essa informação como parâmetro do Intent e logo em seguida

chamamos o startActivity para executar o nosso Intent. No momento em que o startActivity é

chamado, o seu aplicativo envia uma mensagem para o SO Android para abrir o seu browser

padrão.

Note que não há uma diferença na utilização do Intent para uma ação local da sua

aplicação e uma ação do próprio sistema operacional Android, visto que tanto para mudar de tela

quanto para abrir o browser é chamado o método startActivity(Intent).

No exemplo anterior nós criamos um botão e, ao clicá-lo, nós abrimos o browser e

acessamos o endereço especificado no URI adicionado ao Intent. Agora vamos fazer um exemplo

um pouco mais incrementado. Vamos criar um xml de layout, vamos colocar um label, um campo

de texto para o usuário digitar um site e um botão em que, com um clique, nós abriremos o

browser e o endereço especificado.

Primeiro vamos criar o xml de layout:

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"

Android:layout_width="match_parent"

Android:layout_height="match_parent"

Android:orientation="vertical">

Competência 02

24

<TextView


Android:layout_height="wrap_content"

Android:text="Digite a URL" />

<EditText

Android:id="@+id/campoTextoEnderecoWeb"


Android:layout_height="wrap_content" />

<Button

Android:id="@+id/botaoCliqueAqui"

Android:layout_width="wrap_content"


Android:text="Clique aqui!" />

</LinearLayout>

Em seguida, criamos a activity que estará associada a esse xml de layout:


{

@Override



setContentView(R.layout.activity_main);

Button botaoCliqueAqui = (Button)

findViewById(R.id.botaoCliqueAqui);

botaoCliqueAqui.setOnClickListener(this);

}

public void onClick(View view){

EditText campoTextoEnderecoWeb = (EditText)

findViewById(R.id.campoTextoEnderecoWeb);

String enderecoWeb = campoTextoEnderecoWeb.getText().toString();

Competência 02

25

Uri = Uri.parse(enderecoWeb);

Intent it = new Intent(Intent.ACTION_VIEW, uri);

startActivity(it);

}

}

Até ai nenhuma novidade na parte da activity. Ao iniciá-la, o método onCreate é

chamado, especificamos a view que será mostrada através da chamada do método setContentView.

Depois, pegamos o botão através do seu id (R.id.botaoCliqueAqui) que foi especificado no

XML e associamos a ele o evento do clique e dizemos que esse evento foi implementado nessa

activity (this). O clique do botão contém o código que havíamos visto anteriormente, a diferença

é que o endereço web que antes era estático agora é dinâmico e é passado pelo EditText que está

no layout. Na hora de testar não se esqueça de digitar o endereço completo, por exemplo:

www.google.com, não esquecer do http://.

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

Agora vamos aprender como fazer uma ligação usando a classe Intent. Na sessão

anterior, para abrirmos o browser, usamos a ação Intent.ACTION_VIEW e informamos o URI com o

endereço web desejado. De forma similar, para fazer uma ligação, o Intent precisa ter a ação

Intent.ACTION_CALL mais o número do telefone para o qual desejamos ligar.

Existem aplicações que dão a opção ao usuário de fazer uma ligação pra uma central de

atendimento caso ele tenha algum problema na sua utilização. Por exemplo, imagine que você está

desenvolvimento uma aplicação que permite locar um carro de uma estação de origem para

entregá-lo numa estação de destino. Esse carro é movido à eletricidade e não à gasolina ou álcool

como os veículos comuns. No meio do seu percurso, a bateria do carro acaba ou você se envolve

em algum acidente. Assim, é importante que a aplicação disponibilize um número de emergência

para o qual o usuário poderá ligar. Esse número pode ser informado de modo que o usuário saia da

aplicação e digite para fazer a ligação ou clique em um botão e através desse clique a aplicação

envie uma ordem para o sistema operacional para efetuar a ligação. Vamos nos ater a essa última

opção.

http://www.google.com/

Competência 02

26

Então, como faríamos para fazer uma ligação a partir do clique de um botão na nossa

aplicação? Vamos ver um exemplo de um XML de layout que contém um texto explicativo e um

botão que, ao clicá-lo, a ação será ligar para um número de emergência.





Android:orientation="vertical">

<TextView



Android:layout_margin="20dp"

Android:text="Caso você esteja tendo algum problema com a aplicação ligue

para emergência."/>

<Button




Android:text="Ligar para Emergência"

Android:onClick="acaoLigarParaEmergencia"/>

</LinearLayout>

Perceba que o elemento “Button” possui um atributo chamado Android:onClick e como

parâmetro desse elemento especificamos o nome do método presente na sua activity. Essa forma

de especificar e implementar a ação do botão é uma forma diferente da anterior que nós havíamos

visto, você se lembra? Antes, para associar uma ação ao clique do botão, nós colocamos um id no

XML do layout (Android:id="@+id/botaoCliqueAqui") do botão e na activity nós

pegamos esse botão pelo id (Button botaoCliqueAqui = (Button)

findViewById(R.id.botaoCliqueAqui)) e associamos a ele a sua respectiva ação

(botaoCliqueAqui.setOnClickListener(this)). Agora, nós fizemos diferente,

associamos a ação diretamente no XML de layout. Tenha em mente essas duas formas de

Competência 02

27

especificação da ação do botão, será importante você saber para poder dar manutenção num

sistema já existente ou para poder implementar sua própria aplicação.

Agora vamos ver como fica a activity!


@Override




}

public void acaoLigarParaEmergencia(View v) {

Uri telefone = Uri.parse("tel:988998899");

Intent it = new Intent(Intent.ACTION_CALL, telefone);

if (ActivityCompat.checkSelfPermission(this,

Manifest.permission.CALL_PHONE) != PackageManager.PERMISSION_GRANTED) {

return;

}

startActivity(it);

}

}

Antes de executar o código acima, você precisa abrir o arquivo AndroidManifest.xml e

adicionar uma permissão informando que a sua aplicação pode precisar fazer uma ligação. Então,

adicione a seguinte linha no seu AndroidManifest:

<uses-permission Android:name="Android.permission.CALL_PHONE" />

Caso você não coloque essa linha, a chamada ao método startActivity(it)

acusará o erro de permissão e você não poderá executar o código.

Observação: Existe uma ação parecida com a Intent.ACTION_CALL que é a

Intent.ACTION_DIAL, que ao invés de discar e fazer a ligação, apenas disca o número desejado, mas

espera o usuário fazer a confirmação para efetuar a ligação. Faça o teste você mesmo, substitua e

veja o que acontece.

Competência 02

28

2.3 Solicitando ao google maps que exiba um local específico do mapa

A classe Intent também pode ser usada para fazer com que o SO abra um aplicativo de

mapa como, por exemplo, o Google Maps e mostre uma determinada localização geográfica através

do seguinte código:


@Override




Uri uriGeografico =

Uri.parse("geo:0,0?q=Cidade+Universitária,Recife");

Intent it = new Intent(Intent.ACTION_VIEW, uriGeografico);

startActivity(it);

}

}

Perceba que nesse exemplo não será necessário o usuário fazer nenhuma ação, como

clicar no botão, basta ele entrar nessa activity para ela chamar outra activity mostrando a

localização especificada. Nesse exemplo nós estamos especificando um endereço, mas poderia ser

uma coordenada geográfica (latitude e longitude), nesse caso o objeto uriGeografico ficaria da

seguinte forma:

// Coordenadas do Palácio do Planalto, Brasília

Uri uriGeo = Uri.parse("geo:-15.7996165,-47.8591871");

Você pode colocar o seu endereço ou a sua coordenada e ver o Android localizá-la no

mapa, faça o teste! Além disso, você também pode exibir uma rota de um ponto de partida até um

destino específico, basta você determinar as coordenadas de origem e de destino em um serviço do

google maps, atribuir ao Uri e associá-lo ao Intent. Você pode pesquisar por esse exemplo na

internet e fazer o teste.

Competência 02

29

2.4 Acessando contatos da agenda

A classe Intent também pode ser usada pela aplicação para acessar a lista de contatos

do seu usuário. Para isso, a ação que utilizada é uma conhecida nossa, a Intent.ACTION_VIEW,

contudo o outro parâmetro é bem diferente. Para identificar o contato desejado é utilizado o seu

ID, por exemplo: “content://com.Android.contacts/contacts/ID”, onde esse ID varia para cada

contato da sua agenda.

A seguir vamos ver um exemplo de como fazer com que nossa aplicação busque por um

contato específico no momento em que o usuário clica em um botão. Nesse momento você já deve

saber como adicionar um botão na tela e como associar a ele seu respectivo método de onClick.

Você pode fazer isso através do XML ou criar um botão dinamicamente no onCreate da activity.

Aqui eu mostrarei apenas o conteúdo de como ficará o evento de clique do botão, ok?

Uri primeiroContato =

Uri.parse("content://com.Android.contacts/contacts/1");

Intent it = new Intent(Intent.ACTION_VIEW, primeiroContato);

startActivity(it);

Assim como para fazer uma ligação, para você poder acessar a agenda do celular do seu

usuário, no momento da instalação, é necessário que o seu APP solicite a permissão

READ_CONTACTS, então você pode precisar adicionar a seguinte linha no seu AndroidManifest.xml:

<uses-permissionAndroid:name="Android.permission.READ_CONTACTS"/>

ATENÇÃO! Se você rodar o exemplo acima no emulador pode ser que não tenha

contato cadastrado e você pode se deparar com a seguinte mensagem: “Invalid contact uir.”. Então, pra exercitar, eu recomendo você executar o exemplo anterior no seu próprio celular, caso você tenha um dispositivo

Android.

Competência 02

30

Caso você não saiba o ID do usuário e queira visualizar toda a lista de contatos

cadastrados e deixar o usuário livre para escolher, basta você usar o mesmo Uri que usamos

anteriormente omitindo apenas o ID do contato e mudar a ação para Intent.ACTION_PICK. Assim, o

código do onClick modificado ficaria da seguinte forma:

Uri listaDeContatos =

Uri.parse("content://com.Android.contacts/contacts/");

Intent it = new Intent(Intent.ACTION_PICK, listaDeContatos);

startActivity(it);

Após a execução do método startActivity é enviada uma mensagem para o sistema

operacional e é aberta a lista de contatos do dono do dispositivo. Contudo, no momento em que

você clica em um contato qualquer a agenda fecha e retorna para activity anterior. Esse exemplo

não é muito útil, pois o método startActivity tem a função apenas de abrir uma nova activity, então,

quando queremos além de abrir um nova activity receber alguma informação que vem dela,

utilizamos o método starctActivityForResult(intent, código).

2.5 Retornando resultados de uma activity para outra através do método

startActivityForResult

Existem duas formas de mudar de uma activity para outra. A que nós vemos

constantemente faz apenas a mudança de activities através da chamada do método

startActivity(intent). A outra forma é através da chamada do método startActivityForResult(intent,

codigo) que é utilizada quando se quer recuperar alguma informação da tela que foi chamada na

tela que a chamou.

Vou explicar melhor, preste atenção! O método startActivityForResult(intent, código)

recebe 2 parâmetros. O primeiro é o intent, ou seja, é a intenção de abrir uma nova activity e o

segundo é um código, que é um valor usado para identificar a activity que será iniciada, esse código

é chamado de requestCode no Android. Esse mesmo código será enviado de volta quando a activity

aberta for finalizada juntamente com o resultado que se deseja recuperar.

Competência 02

31

Vamos ver um exemplo prático. Através de um clique no botão, vamos abrir a lista de

contatos da agenda, como aprendemos anteriormente, e vamos retornar as informações do

contato escolhido. Antes, quando clicávamos no contato, a activity se fechava e não fazíamos mais

nada com a informação do contato escolhido, na verdade nem a tínhamos ainda, essa informação

ficava perdida. Agora, chamando o método startActivityForResult no clique, nós podemos recuperar

essa informação quando a activity contendo a lista de contatos for fechada, veja o exemplo a seguir.


{

@Override



Button b = new Button(this);

b.setText("Abrir Agenda Telefonica");

b.setOnClickListener(this);

setContentView(b);

}

@Override


Uri listaDeContatos =

Uri.parse("content://com.Android.contacts/contacts/");

Intent it = new Intent(Intent.ACTION_PICK, listaDeContatos);

startActivityForResult(it, 10);

}

@Override

protected void onActivityResult(int requestCode, int resultCode, Intent

data) {

if(requestCode == 10) {

Uri = data.getData();

Cursor = getContentResolver().query(uri, null, null, null,

null);

cursor.moveToFirst();

int nameColumnIndex =

Competência 02

32

cursor.getColumnIndex(ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME)

;

String name = cursor.getString(nameColumnIndex);

Toast.makeText(this, "Contato: " + name,

Toast.LENGTH_SHORT).show();

}

}

}

}

}

Perceba que no nosso exemplo temos três métodos dos quais dois você já conhece e

está bem familiarizado, que são os métodos onCreate, método obrigatório da classe activity que é

chamado sempre que a activity é criada e o método onClick, que é associado ao clique do botão

através do código b.setOnClickListener(this);. Note que existe um método novo

chamado onActivityResult que é o método que é chamado assim que a activity que foi iniciada no

startActivityForResult é encerrada. O código, chamado requestCode, que passamos na chamada, é

retornado no onActivityResult para identificar qual activity foi encerrada, por isso a

checagem no if(requestCode == 10). Dessa forma, é feito o tratamento correto com a

informação esperada. Caso essa nossa activity não tivesse apenas um botão e fosse possível iniciar

mais de uma activity, essa verificação do if(requestCode == 10), faria mais sentido. O

importante é que você perceba que você enviou um código identificador e que esse código foi

retornado, possibilitando o programador saber de onde vem à informação desejada. A classe

Toast.makeText foi utilizada somente para exibir a mensagem com o nome do usuário. Você

também poderia exibir o número do contato ou qualquer outra informação retornada no Intent.

Se você for pesquisar vai ver que os métodos startActivity e startActivityForResult são

bem parecidos, então quando usar um ou outro? Se você quiser apenas mudar de uma tela para

outra sem se importar com o retorno use o starActivity, caso contrário use o startActivityForResult e

na activity que você chamou este método implemente o método onActivityResult.

Esses exemplos são bem simples e didáticos, você pode fazer seus próprios exemplos e

procurar exercícios e matérias complementares na internet.

Competência 02

33

2.6 Intent – Resumo

No decorrer desse capítulo vimos vários possíveis usos para a classe Intent. Ela pode ser

usada tanto para iniciar uma activity que você criou dentro da sua aplicação quanto para chamar

uma activity nativa do Android ou mesmo de outra aplicação e é isso que torna essa classe tão

interessante e especial.

Essa característica de poder se comunicar com outra aplicação é o ponto chave que

diferencia a classe Intent das demais classes Android. Devido a essa característica pode-se ter

inúmeras aplicabilidades, vai depender da utilidade e objetivo da sua aplicação. Imagine que uma

aplicação rode em background e devido a algum evento o usuário precisa ser notificado

urgentemente com um pop up ou uma mensagem de alerta. A aplicação pode detectar esse evento,

mesmo rodando em background, e sinalizar ao usuário a sua ocorrência.

Vamos a outro exemplo. Imagine que uma aplicação envia uma mensagem para o

celular com a intenção de autenticar o usuário da aplicação. A aplicação pode interceptar a

mensagem enviada para o dispositivo e já pegar o código de autenticação na mensagem. Isso

acontece bastante em aplicação de e-mail, que envia uma mensagem com código para o usuário

para ele pegar aquele número e se autenticar. Caso a aplicação seja móvel, ela pode interceptar a

mensagem e já passar para o próximo passo.

Outro exemplo clássico é a leitura do código de barras do celular. Você pode fazer com

que a sua aplicação faça uso do recurso da câmera digital do dispositivo para fazer uma leitura do

código de barras e fazer um pagamento ou ler um QRCode (Quick Response, é um código de barras

bidimensional que pode ser facilmente lido pela câmera da maioria dos dispositivos móveis), isso é

bem comum em aplicações de bancos. Ou ainda permitir ao usuário tirar uma foto e enviar ou

anexar na sua aplicação, como acontece no WhatsApp, por exemplo.

Existem outras aplicabilidades da classe Intent, aqui nós vimos apenas algumas delas. No

decorrer do nosso material continuaremos utilizando a classe Intent. No próximo capítulo,

falaremos sobre interface gráfica e aprofundaremos mais alguns conceitos.

Competência 03

34

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

Neste capítulo aprenderemos mais sobre os componentes de layout, como usá-los e

como organizá-los, apesar de já termos vistos alguns nos capítulos anteriores, como botões e blocos

de textos. No Android existem diversos gerenciadores de layout que podem organizar os elementos

verticalmente, horizontalmente ou mesmo posicionar em um local específico da tela (coordenadas x

e y). Mostraremos vários exemplos e falaremos detalhadamente dos principais componentes.

Vamos lá?

3.1 A classe View

Vamos começar a falar da classe Android.view.View que é considerada a classe mãe dos

componentes visuais do Android. Toda subclasse da classe View deve implementar o método

onDraw(Canvas) cuja função é desenhar o componente na tela. No Android já existem várias classes

que implementam a classe View, mas nada impede que você crie sua própria classe, estenda da

classe View e implemente o seu próprio comportamento para o método onDraw.

No Android nós podemos distinguir dois tipos de componentes: os widgets e os

gerenciadores de layout. O primeiro herda diretamente da classe View e são elementos mais

concisos como Button, TextView, Chronometer, ListView, ImageButton e ImageView, por exemplo.

O segundo tipo herda de ViewGroup e são chamados popularmente apenas de layout.

Nós vamos ver como usar widgets e como usar gerenciadores de layout e vamos ver a

diferença entre os diferentes tipos de gerenciadores. Preste atenção, porque é bastante importante

você saber como usá-los e como fica a dinâmica de organização dos elementos na tela com cada um

dos tipos de layout.

3.2 ViewGroup e gerenciadores de layout

Um gerenciador de layout, como o próprio nome já diz, é um componente visual

utilizado para organizar a disposição dos seus componentes na tela. A seguir, vamos ver uma tabela

com os principais tipos de ViewGroup, ou seja, diferentes classes do Android que herdam

nativamente de ViewGroup e ainda possuem comportamentos específicos e são bastante usadas.

Competência 03

35

COMPONENTE DESCRIÇÃO

FrameLayout É um componente utilizado quando se deseja preencher toda a tela do aparelho.

LinearLayout É utilizado quando se deseja organizar os seus componentes internos de forma horizontal ou vertical.

RelativeLayout

Juntamente com o LinearLayout é um dos componentes mais utilizados. É usado quando se deseja posicionar um componente de forma relativa a outro. Por exemplo, o elemento “A” vai ficar abaixo do “B”, ou acima ou ao lado, ou seja, a localização de “A” vai depender da posição de “B”.

AbsoluteLayout É uma espécie de contêiner onde a posição dos seus componentes é especificada através de coordenadas x e y.

Tabela 2 - Tipos de ViewGroup Fonte: o autor

Descrição: Tabela de tipos de ViewGroup com suas descrições e características.

Existem outras classes que também herdam de ViewGroup como GridLayout e

TableLayout, por exemplo, contudo nesse material vamos focar nesses quatro tipos principais.

Até aqui fizemos poucos exemplos utilizando arquivos de layout em XML. Em muitos

exemplos instanciamos os componentes dinamicamente e associamos a sua Activity

correspondente, mas a partir desse ponto utilizaremos bastante os arquivos de layout escritos em

XML, que é o mais comum de ser encontrado no mercado.

3.3 FrameLayout

Vamos começar pela classe mais simples dos gerenciadores de layout para você

entender melhor o seu conceito. Como vimos na tabelinha, anteriormente, o FrameLayout é um

componente utilizado quando se deseja mostrar algo na tela toda, como uma imagem de fundo que

pode ser uma marca d’água, por exemplo.

A princípio, o elemento que você colocar em um FrameLayout irá ocupar a posição

superior esquerda da tela e, dependendo do seu tamanho ou do que foi definido nos seus atributos,

pode ocupar toda a tela. Ainda assim é possível inserir outros elementos na tela de forma que os

elementos inseridos posteriormente fiquem por cima dos elementos anteriores, seguindo o

conceito de pilha, onde o último elemento fica por cima dos inseridos primeiro. Então, imagine que

você tem uma aplicação e deseja colocar no fundo uma imagem, você poderia usar um

Competência 03

36

FrameLayout onde seu primeiro elemento seria a sua imagem e os demais elementos seriam os

outros componentes da tela que seriam mostrados por cima da imagem, tornando a imagem um

background da tela.

Vamos agora ver na prática como funciona o FrameLayout! O exemplo a seguir é

composto de um FrameLayout contendo um ImageView e vamos ver as variações possíveis dos

atributos layout_widh e layout_height, que constituem a largura e a altura do FrameLayout,

respectivamente.


<FrameLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"



Android:background="#000000">

<ImageView



Android:src="@drawable/Android_mini"/>

</FrameLayout>

O código acima tem como saída a figura 3:

Figura 3 - Imagem do resultado da utilização do componente chamado FrameLayout Fonte: O próprio autor

Descrição: Imagem sendo exibida no topo do lado esquerdo da tela com um fundo da tela do aplicativo cinza.

Competência 03

37

Perceba que tanto no elemento FrameLayout quanto no ImageView suas propriedades

layout_width e layout_height foram setadas como wrap_content. O que isso significa? Para o

FrameLayout significa que a largura e a altura ocuparão somente o tamanho necessário para exibir

o seu conteúdo interno, da mesma forma o ImageView ocupará apenas o tamanho necessário para

exibir a imagem Android_mini. Observe que a imagem Android_mini é transparente e o fundo preto

pertence ao FrameLayout. Com as propriedades de altura e largura setadas como wrap_content o

espaço ocupado pelo FrameLayout será o mesmo espaço ocupado pelo ImageView.

Caso você deseje que o seu FrameLayout ocupe toda a tela, basta mudar as

propriedades de largura e altura de wrap_content para match_parent, dessa forma o componente

irá ocupar todo o espaço designado ao pai (parent), ocupando assim a tela toda e não mais apenas

o espaço ocupado por seus elementos internos. Veja o exemplo a seguir:


<FrameLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"



Android:background="#000000">

<ImageView




</FrameLayout>

Competência 03

38

Figura 4 - Exemplo da utilização do atributo de background Fonte: O próprio autor.

Descrição: É o mesmo exemplo da imagem anterior, sendo adicionado o atributo chamado background. Dessa forma, a imagem continua sendo exibida no topo do lado esquerdo, contudo o fundo da tela do aplicativo está preto com o background sendo especificado através do valor em hexadecimal de #000000 que representa a cor preta.

O mesmo raciocínio é válido para o ImageView. Se quando eu coloco o tamanho do

FrameLayout para match_parent ele ocupa a tela toda, você imagina o que acontecerá se você

trocar o wrap_content dos atributos da imagem para match_parent? Teste você mesmo e veja o

que acontece!

É recomendado que a largura e Aaltura do layout principal ocupem a tela inteira. Logo,

as propriedades layout_width e layout_height devem ter os valores match_parent. Caso ache

necessário, para se certificar de que isso está ocorrendo, mude a cor do background do

componente para poder visualizá-lo. Do contrário ele será transparente e você poderá ficar na

dúvida se ele realmente está ocupando toda a tela.

Esses foram apenas alguns exemplos simples da utilização de um layout juntamente

com a explicação das propriedades de largura e altura. Como havíamos falado anteriormente, o

frame layout coloca os elementos internos empilhados devido a sua natureza de empilhar os

elementos internos, o último elemento a ser inserido ficará por cima dos elementos anteriores.

Então, no caso de você colocar outra ImageView abaixo da primeira com outra imagem, você

perceberá que a primeira imagem pode não ser exibida ou ficar por trás da última. Faça o teste!

Um FrameLayout pode ser usado para fazer uma aplicação definindo uma imagem de

fundo, fazendo com que esta imagem fique por trás do conteúdo da aplicação ou ainda pode fazer

uma tela e colocar como último elemento uma ProgressBar que, quando ativado, ficará por cima de

Competência 03

39

todos os elementos do layout, bloqueando as interações do usuário, fazendo com que ele espere o

processamento de um determinado processo, por exemplo.

Antes de começar a desenvolver uma tela, imagine como ela ficará para, então, você

poder selecionar o melhor layout de acordo com as suas necessidades.

3.4 O famoso LinearLayout

O LinearLayout é o gerenciador de layout mais utilizado, pois possui um conceito

bastante simples: o de organizar os seus componentes internos de forma sequencial na horizontal

ou na vertical. Toda classe de layout deve conter os atributos layout_width e layout_height para

especificar a largura e a altura do componente, respectivamente. Além desses atributos, o

LinearLayout também possui o atributo orientation, onde é possível especificar a orientação dos

seus componentes internos. Os valores desse atributo podem ser horizontal ou vertical, o default,

ou seja, se você não especificar o valor, os elementos serão exibidos horizontalmente. Veja o

exemplo a seguir.



Android:layout_height="match_parent">

<ImageView




<ImageView



Android:src="@drawable/Android_mini2"/>

</LinearLayout>

Competência 03

40

Figura 5 - Imagens representando o uso do componente de LinearLayout Fonte: O próprio autor.

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

Esse exemplo é semelhante ao exemplo do FrameLayout. Mudei apenas o tipo do

ViewGroup para LinearLayout, perceba que as imagens são exibidas uma ao lado da outra, ou seja, o

LinearLayout ocupa a tela toda, porque sua largura e altura foi especificada como match_parent e

os seus elementos internos são exibidos lado a lado, de forma sequencial, pois não foi especificado

o atributo orientation que por padrão é horizontal. Caso você tivesse especificado explicitamente

como vertical (Android:orientation="vertical"), o segundo ImageView seria

mostrado abaixo do primeiro, faça o teste!

Se você colocar mais componentes do que é possível exibir na tela, pode ser que esses

componentes não apareçam, no nosso exemplo anterior as duas ImageView apareceram na tela,

mas e se ao invés de duas fossem quatro, o que aconteceria? Bom, como sobrou um pouco de

espaço entre a segunda imagem e a margem direita, a terceira imagem seria redimensionada para

caber no espaço restante, contudo a quarta imagem não iria aparecer, pois não existe espaço

suficiente no layout para ela, então você só veria três imagens. Para visualizar a quarta imagem

você pode tentar colocar o seu dispositivo na horizontal, dessa forma a largura do layout irá

aumentar e será possível visualizar a outra imagem. Veja como ficariam os dois cenários descritos

na figura abaixo.

Competência 03

41

Figura 6 - a) Representa os quatro elementos onde só três aparecem e o terceiro aparece redimensionado para caber na tela e a figura. b) Mostra as quatro imagens sendo exibidas com o telefone na horizontal.

Fonte: O próprio autor. Descrição: Existem duas imagens, uma imagem foi chamada de A e a outra de B. A imagem A representa a visão do celular na vertical onde estão sendo exibidas três imagens. A primeira imagem encontra-se no topo, do lado esquerdo, e a segunda está no topo do lado direito da primeira e assim por diante. As duas primeiras imagens estão com os tamanhos originais, a terceira encontra-se com o tamanho reduzido para caber na tela e a quarta imagem não foi exibida. A imagem B representa o celular na horizontal e mostra quatro imagens. As quatro imagens estão no topo da tela a partir do lado esquerdo e todas as imagens estão com o mesmo tamanho. Após a quarta imagem ainda sobra um pequeno espaço para acabar a tela do celular.

3.5 RelativeLayout

A classe RelativeLayout também é bastante utilizada, através dela é possível posicionar

um componente em relação ao outro. Como assim professor? Por exemplo, imagine que você tem

uma imagem no topo da sua tela, usando o RelativeLayout é possível você especificar que um

determinado elemento deve aparecer ao lado dessa imagem (o programador informa se é lado

direito ou lado esquerdo), acima dela ou abaixo dela.

Mas como dizer que um componente deve aparecer ao lado, abaixo ou acima de outro?

Primeiro, você precisa nomear (ou referenciar, que é o termo mais comum) especificando um ID

para cada componente da tela, assim o Android vai entender. Assim, por exemplo, você vai poder

dizer para o Android: eu quero que o componente A fique abaixo do componente B. Vamos ver

alguns atributos importantes que podem ser usados pelo RelativeLayout na tabela a seguir.

ATRIBUTO DESCRIÇÃO

Android:layout_below Posiciona o elemento abaixo de outro. Android:layout_above Posiciona o elemento acima de outro.

Android:layout_toLeftOf Posiciona o elemento à esquerda de outro. Android:layout_toRightOf Posiciona o elemento à direita de outro.

Android:layout_marginTop Utilizado para definir um espaço (margem) na parte superior (Top) do componente.

Competência 03

42

Android:layout_marginBottom Utilizado para definir um espaço (margem) na parte inferior (Bottom) do componente.

Android:layout_marginRight Utilizado para definir um espaço (margem) na parte direita (Right) do componente.

Android:layout_marginLeft Utilizado para definir um espaço (margem) na parte esquerda (Left) do componente.

Tabela 3 - Atributos do RelativeLayout

Fonte: o autor Descrição: Tabela com os atributos de RelativeLayout que podem ser usados para posicionar os elementos na tela.

Agora que já aprendemos o conceito de RelativeLayout e vimos os atributos de

posicionamento que podem ter seus componentes internos, vamos ver um exemplo de um

formulário de cadastro com nome e senha e confirmação de senha fazendo o uso do

RelativeLayout.


<RelativeLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"



<TextView

Android:id="@+id/txtViewDescricao"




Android:gravity="center"

Android:textSize="20dp"

Android:text="Formulário de cadastro de usuário" />

<TextView

Android:id="@+id/txtViewLogin"

Android:layout_width="155dp"


Android:layout_below="@+id/txtViewDescricao"

Android:layout_marginBottom="20dp"

Android:layout_marginLeft="15dp"

Android:text="Login" />

Competência 03

43

<EditText

Android:id="@+id/editTxtLogin"



Android:layout_alignTop="@+id/txtViewLogin"

Android:layout_toRightOf="@+id/txtViewLogin"

Android:background="@Android:drawable/editbox_background"

/>

<TextView

Android:id="@+id/txtViewSenha"



Android:layout_below="@+id/txtViewLogin"



Android:text="Senha" />

<EditText

Android:id="@+id/editTxtSenha"



Android:layout_alignTop="@+id/txtViewSenha"

Android:layout_toRightOf="@+id/txtViewSenha"


Android:password="true"

/>

<TextView

Android:id="@+id/txtViewConfirmacaoDeSenha"



Android:layout_below="@+id/editTxtSenha"



Android:text="Confirmação de senha" />

Competência 03

44

<EditText

Android:id="@+id/editTxtConfirmacaoDeSenha"



Android:layout_alignTop="@+id/txtViewConfirmacaoDeSenha"

Android:layout_toRightOf="@+id/txtViewConfirmacaoDeSenha"


Android:password="true"

/>

</RelativeLayout>

O código acima gera a imagem da figura 7:

Figura 7 - Imagem de um formulário de cadastro feito a partir da utilização do RelativeLayout. Fonte: O próprio autor.

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

Competência 03

45

O RelativeLayout é um componente bastante usado e bem flexível. Para adicionar um

novo componente à tela, basta colocá-lo relativo a outro já existente, contudo, perceba que ao

fazer isso você vai aumentando a complexidade da sua tela. Imagine uma tela de cadastro com um

formulário contendo vários campos para o usuário preencher, para adicionar um novo campo ou

um novo componente no RelativeLayout pode não ser uma tarefa fácil, pois a adição de um novo

elemento impacta diretamente na posição de todos os outros podendo, inclusive, quebrar todo o

layout.

3.6 AbsoluteLayout (deprecated ou depreciado)

Agora, vamos falar um pouco da classe AbsoluteLayout. Apesar de ser considerada pelo

Google como uma classe deprecated, ela pode ser encontrada em algumas aplicações legados, ou

seja, aplicações antigas, e que ainda precisam de manutenção. Falaremos de AbsoluteLayout para

explicar o conceito de deprecated e, caso você se depare com esse tipo de classe, você vai saber

como ela funciona.

Deprecated é o nome que se dá a classes que foram descontinuadas, ou seja, classes

que existem, contudo o uso não é recomendado. Elas são consideradas perigosas, pois o seu uso

pode gerar um comportamento diferente do esperado pelo programador. O conceito de deprecated

é o mesmo para qualquer linguagem e não apenas para Android. Você vai encontrar classes

depracted em Java, Android, C/C++, C# e várias APIs que existem no mercado. Sempre que você vir

uma classe com o nome deprecated, não a utilize ou, se ela existir em um sistema que você esteja

dando manutenção, troque-a! Para todo código utilizando uma classe deprecated existe uma nova

forma de fazer aquela funcionalidade de maneira melhor e mais segura.

A classe AbsoluteLayout permite ao programador controlar as coordenadas exatas de

seus componentes, para isso basta especificar sua posição X e Y utilizando os atributos

Android:layout_x e Android:layout_y, respectivamente. Você entente qual é o problema de

especificar as posições exatas de um componente na tela? Cada equipamento tem um tamanho de

tela específico, existem equipamentos com telas menores e outros com telas maiores de diferentes

resoluções. Então, você especificar as coordenadas exatas dos componentes pode ser um problema,

o ideal é que independentemente do tamanho da tela os componentes se ajustem a ela

automaticamente.

Competência 03

46


<AbsoluteLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"



<TextView

Android:id="@+id/txtViewDescricao"




Android:layout_x="20px"

Android:layout_y="10px"

Android:textSize="20dp"

Android:text="TÍTULO - Vamos ver agora um exemplo de AbsoluteLayout!" />

<TextView



Android:layout_x="450px"

Android:layout_y="250px"

Android:text="TEXTO 01 - Veja a posição desse texto no meu exemplo (veja o

print) e no seu celular ou emulador." />

</AbsoluteLayout>

Competência 03

47

Figura 8 - Exemplo da utilização do AbsoluteLayout Fonte: o autor.

Descrição: A imagem mostra dois blocos de texto exemplificando a utilização do AbsoluteLayout onde foi especificado as coordenadas dos seus elementos. O primeiro está sendo exibido ocupando três linhas a partir do canto superior esquerdo da tela (na posição x igual 20 pixels e y igual a 10 pixels) e o sendo bloco de texto está sendo exibido abaixado do primeiro, na posição x igual a 450 pixels e y igual a 250 pixels.

Agora execute o exemplo acima no seu celular ou emulador e verifique a posição dos

textos (TITULO e TEXTO 01). Pode ser que no seu dispositivo ou emulador o TEXTO 01 fique cortado,

pois você pode possuir um dispositivo com a resolução menor que o meu, ou que o TITULO no seu

dispositivo ou emulador tenha a disposição das palavras de forma diferente no seu teste. Pode ser

ainda que ocupe mais linhas ou menos linhas ou que a quebra de linha tenha sido feita de forma

diferente.

3.7 Resumo

Conforme vimos nas sessões anteriores deste capítulo, os gerenciadores de layout são

utilizados para organizar seus componentes internos. Você pode, inclusive, colocar um gerenciador

de layout dentro do outro, ou seja, você pode ter como elemento raiz um LinearLayout, por

exemplo, e dentro dele definir vários outros gerenciadores de layout.

Digamos que você tenha uma tela de formulário e cada item deva ficar um abaixo do

outro e ao final do formulário você tem dois botões, um para confirmar e outro para voltar ou

Competência 03

48

cancelar. Os itens de formulário estão dispostos um abaixo do outro, enquanto os botões deveriam

ficar lado a lado. Como você faria? Quais gerenciadores de layout você usaria? Uma opção é usar

um LinearLayout (como sendo o principal ou raiz ou root) com o orientation vertical para os campos

do formulário e dentro desse componente, por último, inserir outro LinearLayout (secundário)

definindo o atributo orientation como horizontal para os botões ficarem lado a lado. Faça o teste!

É importante você conhecer os diferentes tipos de gerenciadores de layout para

escolher o melhor para atender a sua necessidade. Não existe um componente melhor que o outro,

cada um foi criado para um propósito específico e cabe ao desenvolvedor fazer a escolha correta.

Competência 04

49

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

A classe View é a principal classe de layout no Android. Ela é a classe responsável por

desenhar algo na tela. Nesse capítulo será mostrado como trabalhar com recursos de texto, cores,

estilos e imagens que serão exibidos na View e falaremos um pouco também da classe R, usada

para acessar esses recursos em qualquer lugar da aplicação.

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

No Android a classe R é o ponto central de acesso a todos os recursos da aplicação seja

texto, cor ou imagem. Então, se você adicionar um arquivo XML na pasta de layout, para acessá-lo

basta fazer isso por meio da classe R, obedecendo a seguinte sintaxe R.layout.nome_do_arquivo.

De forma similar, outros arquivos também podem ser acessados. Quando um projeto no

Eclipse ou no Android Studio é criado automaticamente, surge o arquivo /res/values/strings.xml.

Esse arquivo pode conter várias mensagens que podem ser recuperadas nos arquivos de layout ou

mesmo nos códigos das classes em Java. Para acessar essas strings nos arquivos XML basta digitar

@string/nome_da_string.

Veja o exemplo do arquivo XML a seguir e veja como acessar o nome da aplicação

definido nele.

<resources>

<string name="app_name">ExemplosDeView</string>

</resources>

<activity

android:name=".MainActivity"

android:label="@string/app_name">

Isso é muito útil! Imagine que o programador defina uma mensagem no seu arquivo

strings.xml e use essa mensagem em diversos pontos da aplicação. Fazendo dessa forma a

mensagem encontra-se centralizada, ou seja, todos os pontos da aplicação fazem referência à

mesma string. Então, caso essa mensagem mude, basta você acessar o arquivo strings.xml e alterá-

Competência 04

50

la e automaticamente todos os locais que fazem referência a essa mensagem estarão com a sua

mensagem atualizada. Se o programador escrever essa mensagem de forma repetida em diversos

pontos, caso a mensagem mude, ele vai ter que mudar em todos os locais, tendo assim mais

trabalho.

A seguir veremos em detalhes como definir arquivos de cores, mensagens e estilos da

aplicação e como acessá-los e fazer uso do seu conteúdo.

4.2 Arquivo com as mensagens da aplicação

Vamos estudar agora mais detalhadamente o arquivo strings.xml criado por padrão

tanto no Eclipse quanto no Android Studio e usado para armazenar as mensagens do projeto.

Também é possível definir outros arquivos de mensagens desde que você siga o padrão e estrutura

esperados.

Por padrão, os arquivos de recursos devem iniciar com a tag <resources> e, no caso dos

arquivos de texto, dentro da tag resources podem existir várias tags do tipo <string>, onde o

programador define uma chave única, usada para acessar a informação e um valor associado a essa

chave. Vamos ver um exemplo:

<resources>

<string name="chave_01">Valor 1</string>

<string name="chave_02">Valor 2</string>

<string name="mensagem_sucesso">Operação realida com sucesso!</string>

<string name="mensagem_erro">Desculpe, ocorreu um erro.</string>

</resources>

Para essas mensagens dentro de uma classe Java basta usar a classe R. No caso, para

exibir a string com a chave chave_01 basta fazer R.string.chave_01. Se for necessário usar alguma

dessas mensagens em um arquivo de layout de tela, ou seja, num arquivo XML, a sintaxe muda um

pouco, então ficaria da seguinte forma @string/mensagem_sucesso.

Competência 04

51

4.3 Arquivo com as cores da aplicação

Da mesma forma que é criado o arquivo strings.xml por padrão, também é criado o

arquivo colors.xml (no Android Studio). Também pode ser criado outro arquivo com outro nome

desde que siga o padrão. Assim como no arquivo de mensagens, o arquivo de cores também deve

conter a tag <resources>, porém ao invés da tag string deve-se usar a tag color, como no exemplo a

seguir:


<resources>

<color name="colorPrimary">#3F51B5</color>

<color name="colorPrimaryDark">#303F9F</color>

<color name="colorAccent">#FF4081</color>

</resources>

Para usar uma cor no arquivo Java podemos usar a classe R obedecendo a sintaxe

R.color.nome_da_cor (ex: R.color.colorPrimary), já para utilizar no arquivo XML de layout a sintaxe

fica da seguinte forma @color/nome_da_cor (@color/colorAccent).

Aplicando esse conhecimento para colocar a cor em um TextView vamos especificar a

sua propriedade background:

<TextView

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:textSize="20dp"

android:background="@color/colorPrimary"

android:text="@string/mensagem_sucesso" />

Também poderia ter sido colocado o RGB diretamente no código, por exemplo,

android:background="#3F51B5". Contudo, é sempre recomendado utilizar o recurso em vez de

deixar as cores fixas (e mensagens) fixas no código, pois, como já foi citado, essa centralização

facilita a manutenção e torna a aplicação bem mais simples e fácil de entender.

Competência 04

52

4.4 Criando estilos

Você já fez alguma página em HTML? Se a sua resposta foi sim você com certeza já ouviu

falar em CSS, que são arquivos usados para definir o layout dos componentes de um arquivo HTML.

Assim como no HTML, no Android você também pode definir um arquivo (XML) de estilos, nele é

possível definir de uma só vez um determinado padrão de cor, tipos de fontes, imagens,

backgrounds e muitas outras propriedades e configurações de layout dos componentes da sua

aplicação.

Definido um XML de estilo você pode tanto usá-lo a partir de uma classe Java quanto de

um arquivo de layout. De forma similar ao arquivo de mensagens e cores, o arquivo de estilos deve

iniciar com a tag <resources> e deve ser seguido por tags <style>, onde você define um nome para

posteriormente acessá-lo, da seguinte forma, por exemplo, <style name=”nome_do_estilo”>. A

seguir vamos ver um exemplo real de um arquivo de estilo.


<resources>

<style name="MeuEstilo">

<item name="android:textSize">14dp</item>

<item name="android:textColor">#000000</item>

</style>

</resources>

Para aplicar esse estilo a partir da classe Java, basta acessar a famosa classe R da

seguinte forma R.style.nome_do_estilo. E, para invocar esse estilo em um arquivo XML de layout

basta fazê-lo assim @style/nome_do_estilo. No nosso exemplo, como o nome do estilo é

“MeuEstilo”, basta fazer a substituição da variável nome_do_estilo por “MeuEstilo” para aplicá-lo.

Note que a sintaxe da utilização do arquivo de mensagens, cores e estilos são bem

parecidas, pois todos são arquivos de recursos (por isso devem iniciar com a tag <resources>). Para

usar o arquivo de mensagens você vai fazer R.string, para o arquivo de cores R.color e para o

arquivo de estilo R.style.

Competência 04

53

4.5 Usando temas do Android

Um tema é um estilo que pode ser aplicado a uma activity ou a uma aplicação inteira.

Para customizar você pode usar a propriedade android:theme tanto na tag <application>, para

especificar o tema da aplicação como um todo, quanto na tag <activity>. Você encontra essas tags

no arquivo AndroidManifest.xml. Lembre-se de que sempre que você adicionar uma nova activity

você tem que declará-la nesse arquivo, assim como as permissões de acesso à internet e acesso à

câmera, por exemplo.

A seguir veremos um código representando um arquivo AndroidManifest.xml e sua

respectiva tela principal:


<manifest xmlns:android="http://schemas.android.com/apk/res/android"

package="com.example.gilsondeoliveira.exemplosdeview">

<application

android:allowBackup="true"

android:icon="@mipmap/ic_launcher"

android:label="@string/app_name"

android:supportsRtl="true">

<activity


android:label="@string/app_name">

<intent-filter>

<action android:name="android.intent.action.MAIN" />

<category android:name="android.intent.category.LAUNCHER"

/>

</intent-filter>

</activity>

</application>

</manifest>

Competência 04

54

Figura 9 - Imagem representando o tema especificado no código anterior. Fonte: O próprio autor.

Descrição: Imagem com um label com o valor ExemplosDeView de cor branca e de fundo cinza escuro.

Existem outros temas padrões do Android como Theme.Light ( android:theme =

"@android:style / Theme.Light") e Theme.Dialog ( android:theme =

"@android:style / Theme.Dialog"). O primeiro tem uma aparência mais leve com fundo

branco e o segundo faz com que as telas da aplicação sejam exibidas na forma de janelas de

diálogo. Faça o teste!

Apesar do Android já prover esses diferentes temas, nada impede que o desenvolvedor

crie o seu próprio tema do zero ou mesmo estenda o tema que já existe e altere e adapte as

características desejadas. Para isso, basta você criar um style da seguinte forma:


<resources>

<color name="black">#000000</color>

<style name="MeuTema" parent="@android:style/Theme.Light">

<item name="android:windowBackground">@color/black</item>

</style>

</resources>

Note que foi especificado o tema que foi estendido ( parente = "@

android:style / Theme.Light") e o nome do novo tema (MeuTema) e dentro da tag style

Competência 04

55

é só você customizar o que deseja, no caso, a única coisa que foi mudada foi a cor da janela, ou seja,

ao invés de branca, agora ela será preta. Lembre-se de que se você criou um novo tema e é

necessário especificá-lo na tag <application> ou <activity>, no caso ficaria

(android:theme="@style/MeuTema"). Veja o antes e depois a seguir:

Figura 10 - Imagem mostrando a diferença entre 2 temas, o tema light já provido pelo Android e um tema customizado. Fonte: o autor.

Descrição: A imagem mostra dois prints da mesma tela usando temas diferentes. O primeiro print mostra a tela com um tema próprio do Android, disponível para qualquer usuário usar chamado Theme.Light. E a outra imagem mostra a mesma tela com um tema diferente. Esse tema diferente é o Theme.Light, com o fundo modificado através de uma customização.

Existem muitas aplicações que usam um tema personalizado, mas também existem

muitas outras que usam alguns dos temas já existentes no Android e que atendem muito bem

muitos projetos. Porém, é bastante importante saber que você pode utilizar os vários temas

disponibilizados pela plataforma e que você pode criar o próprio tema ou customizar um tema

existente.

4.6 Definindo as dimensões dos componentes de layout

É bastante comum na definição de altura e largura de elementos de layout utilizar

valores como match_parent e wrap_content (inclusive já usamos bastante até aqui). Entretanto,

também é possível definir valores específicos, ou seja, valores numéricos seguidos de uma notação

indicando a unidade de medida que está sendo usada como, por exemplo, 20px (pixels) ou 10mm

(milímetros). Assim, é possível controlar exatamente o tamanho do componente.

Competência 04

56

Para definir as dimensões no Android é possível usar as seguintes notações:

NOTAÇÃO DESCRIÇÃO

px (pixels) Especifica o número de Pixels que o componente irá ocupar na tela.

in (inches) Inches significa polegadas, é uma medida baseada no tamanho físico da tela.

mm (milímetros) Baseado no tamanho em milímetros da tela.

pt (pontos) Corresponde a 1/72 de uma polegada, também baseado no tamanho físico da tela.

dp(Density-independent Pixels)

Essa unidade é relacionada à resolução da tela. Por exemplo, se a resolução da tela é de 160 dpi, significa que cada dp representa 1 pixel em um total de 160. É a notação mais usada.

sp

É parecido com o dp. Essa unidade é mais recomendada para utiliza quando se quiser especificar o tamanho de uma fonte, para que ela seja automaticamente ajustada conforme a resolução da tela do usuário.

Tabela 4 – Notações

Fonte: o autor Descrição: Tabela que informa os diferentes tipos de notação para posicionamento e definição de tamanho de componentes da tela com suas respectivas descrições.

Dentre as notações descritas, é importante perceber que utilizar a notação em pixels é

bastante perigoso, pois, dependendo da resolução do usuário, um componente pode ter tamanhos

diferentes, além de ser muito provável que você tenha problemas com a disposição e exibição

desses componentes. Dessa forma, o uso da notação em pixels não é recomendado e o mais

utilizado é o uso da notação em dp, já que os componentes se ajustam de acordo com a resolução

das telas dos usuários. É importante saber a diferença entre essas notações e quais as mais usadas e

recomendadas, uma vez que o maior problema que um desenvolvedor de aplicativos tem hoje é

criar aplicativos quem funcionem em diversos aparelhos com diferentes telas e resoluções,

incluindo smartphones e tablets.

4.7 Resumo

Nesse capítulo falamos sobre a famosa classe R e como fazemos para criar, definir e

acessar os arquivos que contêm as mensagens, cores e estilos da aplicação. Falamos também da

importância desses arquivos para a manutenção da aplicação através da centralização das

informações.

Competência 04

57

Vimos as diferentes formar de definir as dimensões dos componentes da tela de um

aplicativo Android e a importância de saber qual unidade de medida usar. É importante o

programador ter em mente esses conceitos, pois uma aplicação Android pode rodar em diferentes

tipos de dispositivos com resoluções de telas diferentes e, caso seja usada uma medida de

posicionamento ou tamanho incorreto ou não recomendado, pode ocasionar o mal funcionamento

da aplicação.

Competência 05

58

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

A classe View é a classe base dos componentes visuais, responsável pela criação e

caracterização de qualquer componente gráfico em uma aplicação Android. Tanto os gerenciadores

de layout que vimos no capítulo anterior (que herdam de ViewGroup, que por sua vez herdam de

View) quanto os componentes que veremos a seguir, herdam da classe View e são utilizados para

montar o layout das telas de uma aplicação Android.

Muitas vezes chamamos uma View de componente ou elemento no contexto de uma tela da

aplicação. Toda subclasse de View implementa o método onDraw (Canvas canvas) que é

responsável por desenhar o componente na tela. Geralmente utilizamos componentes já prontos

do próprio Android como TextViews, Buttons, mas você também pode criar o seu próprio

componente, ou seja, sua própria View, basta criar uma classe que herde de View e implementar o

método onDraw (Canvas).

A seguir vamos ver os métodos mais comuns e importantes da classe View. Para a lista

completa de métodos fazer a leitura da documentação

(https://developer.android.com/reference/android/ view/View.html):

MÉTODO DESCRIÇÃO

onDraw(Canvas) Método responsável por desenhar o componente de layout na tela.

setPadding(esquerda, cima, direita, baixo)

Método responsável por informar o espaçamento à esquerda, acima, à direita e abaixo em pixels que devem ser colocados na tela antes de inserir o componente. Existe também uma propriedade que pode ser definida no XML com essa mesma função chamada android:padding onde você pode definir um único valor e esse mesmo valor ser aplicado a todos os parâmetros. Caso seja necessário informar um valor diferente para cada espaçamento, basta usar os atributos android:paddingLeft, android:paddingTop, android:paddingRight e android:paddingBottom, respectivamente.

https://developer.android.com/reference/android/%20view/View.html

Competência 05

59

setVisibility(visibility)

O método setVisibility pode receber três valores definidos pelas constantes View.VISIBLE, View.INVISIBLE e View.GONE. A primeira constante, como o nome já diz, faz com que o componente seja exibido na tela, já as outras duas INVISIBLE e GONE fazem com que o componente não seja exibido. A diferença entre elas é que a constante View.INVISIBLE não exibe o elemento, mas deixa o espaço que ele usaria reservado na tela (em branco), enquanto que a constante View.GONE faz com que se remova tanto o elemento quanto o espaço que ele usaria da tela. No XML o método equivalente é o android:visibility que pode receber os valores: visible, invisible e gone. Por padrão, quando você criar uma View ela será exibida na tela sem a necessidade de ser especificada a visibilidade, contudo, esse método é bastante usado quando se deseja criar telas dinâmicas, principalmente formulários.

onKeyDown(codigoDaTecla, evento) e onKeyUP(codigoDaTecla, evento)

São métodos chamados pelo Android quando o usuário pressiona uma tecla. Esses métodos são bastante usados para criar atalhos na aplicação. Você também pode sobrescrever esses métodos na sua activity para capturar as teclas digitadas pelo usuário.

Tabela 5 - Principais métodos da classe View

Fonte: o autor Descrição: Tabela responsável por mostrar os principais métodos da classe View com seus respectivos parâmetros e apresentar uma descrição do funcionamento dos métodos.

5.1 TextView

A classe TextView é uma das subclasses mais simples da classe View. Ela é responsável

por desenhar um texto (também chamado de label) na tela. Vamos ver alguns exemplos a seguir,

diferentes formas de usar um label:


<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

android:layout_width="match_parent"

android:layout_height="match_parent"

android:orientation="vertical">

<TextView

Competência 05

60



android:text="Hello World!" />

<TextView



android:autoLink="web"

android:text="http://www.google.com" />

<TextView



android:background="#0000ff"

android:textColor="#ffffff"

android:text="Texto branco (text_color) e fundo azul (background)" />

</LinearLayout>

Figura 11 - Exemplo de três TextViews com atributos diferentes. Fonte: o autor.

Descrição: a imagem mostra três textos exemplificando o uso do componente TextView. No texto está escrito um Hello World! Simples, sem nenhuma customização. O segundo mostra um link web www.google.com de cor rosa, que ao ser clicado abre um browser. E o terceiro é um TextView em que a cor do texto foi modificada para branco e a cor do fundo para azul.

http://www.google.com/

Competência 05

61

5.2 EditText

A classe EditText é utilizada quando se deseja criar um campo onde o usuário irá digitar

informações de texto. Esse texto pode ser um texto normal (letras mais números), apenas números,

apenas letras ou mesmo senhas.

A classe EditText é bastante utilizada na criação de formulários. Vamos ver um exemplo

clássico da sua utilização através de um formulário de login e senha:



android:orientation="vertical"


android:layout_height="match_parent">

<TextView




android:text="Login:"/>

<EditText



android:textSize="20dp"/>

<TextView




android:text="Senha:"/>

<EditText



android:password="true"

android:textSize="20dp"/>

Competência 05

62

</LinearLayout>

Figura 12 - Exemplo de um formulário com utilização de dois campos de texto representados por dois EditText.

Fonte: o autor. Descrição: a imagem mostra um texto com o valor Login: no canto esquerdo superior, abaixo está um campo de texto que permite o usuário digitar o seu login. Abaixo do campo de texto do login está um texto com o valor Senha: e abaixo do texto senha existe o seu respectivo campo de texto para o usuário digitar a senha.

Note que o segundo EditText representa um campo de senha definido pelo atributo

android:password que é usado para camuflar os caracteres que são escritos.

5.3 Button e ImageButton

Tanto a classe Button quanto a ImageButton são usadas para criação de botões. A

diferença como o próprio nome já diz, é que a classe ImageButton permite que esse botão seja

representado através de uma imagem.

A seguir veremos um exemplo com uma tela com dois botões, um Button e um

ImageButton.



android:orientation="vertical" android:layout_width="match_parent"


Competência 05

63

<Button

android:id="@+id/btn01"



android:text="Botão 01"/>

<ImageButton

android:id="@+id/imgBtn02"



android:src="@drawable/android_mini2"/>

</LinearLayout>

A classe MainActivity é responsável por controlar os eventos de clique dos botões,

tanto do ImageButton, quanto do Button.

public class MainActivity extends Activity{

@Override



setContentView(R.layout.button_image_button_layout);

Button btn01 = (Button) findViewById(R.id.btn01);

btn01.setOnClickListener(new View.OnClickListener() {

@Override


Toast.makeText(MainActivity.this, "Classe Button",

Toast.LENGTH_LONG).show();

}

});

ImageButton imgBtn02 = (ImageButton) findViewById(R.id.imgBtn02);

imgBtn02.setOnClickListener(new View.OnClickListener() {

@Override


Competência 05

64

Toast.makeText(MainActivity.this, "Classe ImageButton",

Toast.LENGTH_LONG).show();;

}

});

}

}

Observe que a imagem exibida no ImageButton é informada através do preenchimento

do atributo src, que informa onde a imagem se encontra (/app/src/main/res/drawable), dentro do

seu projeto. Você também poderia ter definido a imagem dinamicamente na classe MainActivity, a

imagem poderia ser uma imagem externa, da web (usar o método setImageURI(uri)).

A imagem a seguir mostra o exemplo anterior rodando e sendo clicado no ImageButton.

Figura 13 - Imagem representando a utilização da View Button e de um ImageButton Fonte: o autor.

Descrição: a imagem exibe dois botões, um abaixo do outro. O primeiro botão é chamado de Botão 01 e o segundo botão possui uma imagem como conteúdo.

Mais adiante, ainda neste capítulo veremos outros detalhes sobre a utilização da classe

Toast, responsável pela exibição de mensagens.

Competência 05

65

5.4 CheckBox

Um Checkbox no Android é um componente que, não só no Android como de modo

geral, pode possuir o estado de marcado ou desmarcado. Geralmente é usado quando se quer fazer

uma escolha mútua, que não seja mutuamente exclusiva. Por exemplo, imagine que existe um

formulário que pergunta quais tecnologias você domina ou conhece e existem várias opções:

Objective C, Java, Ruby, C/C++, se você conhecer mais de uma tecnologia o ideal é que o

componente usado para representar essas opções seja um checkbox. Para ilustrar esse cenário, veja

o exemplo a seguir.



android:orientation="vertical" android:layout_width="match_parent"


<TextView



android:text="Assinale as tecnologias que você já trabalhou:"/>

<LinearLayout



<CheckBox



android:text="Java"/>

<CheckBox



android:text="C/C++"/>

<CheckBox


Competência 05

66


android:text="C#"/>

<CheckBox



android:text="JavaScript"/>

</LinearLayout>

</LinearLayout>

O id definido no arquivo XML é usado para recuperar o checkbox no código Java,

dessa forma é possível verificar se o checkbox está marcado ou não. Isso é feito através do método

isChecked().

CheckBox chkBox = (CheckBox) findViewById(R.id.checkboxJava);

boolean checkboxSelecionado = chkBox.isChecked();

5.5 RadioButton

O componente RadioButton é usado quando dentre algumas opções o usuário só pode

escolher uma, ou seja, as opções são mutuamente exclusivas, não sendo possível ter mais de uma

resposta para a mesma pergunta. Por exemplo, o RadioButton é o componente mais usado quando

se deseja saber o sexo de um usuário, este pode ser masculino ou feminino, ou quando se quer

fazer uma pergunta cuja resposta é sim ou não.






<TextView

android:id="@+id/lblSexo"



Competência 05

67

android:text="Sexo:"/>

<RadioGroup

android:id="@+id/radioGroup"


android:layout_height="match_parent"

android:orientation="horizontal">

<RadioButton

android:id="@+id/radioM"



android:text="Masculino"/>

<RadioButton

android:id="@+id/radioF"



android:text="Feminino"/>

</RadioGroup>

</LinearLayout>

O RadioGroup indica que seus elementos internos são mutuamente exclusivos, quando

você escolher um RadioButton o outro vai ser automaticamente desmarcado. Para verificar se o

RadioButton está marcado você pode usar o método do RadioGroup chamado

getCheckedRadioButtonId() da seguinte forma:

RadioGroup radioGroup = (RadioGroup)findViewById(R.id.radioGroup);

boolean radioM_Checked = R.id.radioM == radioGroup.getCheckedRadioButtonId();

Caso o valor de radioM_Checked seja true indica que o RadioButton com o valor

Masculino está selecionado, da mesma forma pode-se fazer para o outro RadioButton. Vamos ver

como fica o layout do nosso exemplo:

Competência 05

68

Figura 14 - Exemplo da utilização do componente de RadioButton com o sexo: Masculino ou Feminino. Que são mutualmente exclusivos.

Fonte: o autor. Descrição: a imagem mostra um texto no canto superior esquerdo com o valor Sexo: e abaixo estão dois RadioButton usadoS, geralmente, para representar escolhas que são mutuamente exclusivas, no caso os seus valores são masculinos e femininos, que se encontram lado a lado na imagem.

5.6 Spinner

A classe Spinner no Android é responsável por desenhar na tela um combo box, ou seja,

um conjunto de opções. Para que o combo seja preenchido com uma lista é necessário a

implementação da classe SpinnerAdapter.

A seguir vamos ver um exemplo de um combo com uma lista de países e ao selecionar o

país a aplicação irá exibir a sua bandeira.






<TextView



android:text="Selecione um país:"/>

<Spinner

android:id="@+id/combobox"


Competência 05

69

android:layout_height="wrap_content"/>

<ImageView

android:id="@+id/imgPais"


android:layout_height="match_parent" />

</LinearLayout>

public class MainActivity extends Activity{

private int[] imagens = {R.drawable.brasil, R.drawable.eua,

R.drawable.inglaterra, R.drawable.franca,

R.drawable.canada};

private String[] paises = new String[]{"Brasil", "Estados Unidos",

"Inglaterra", "França", "Canada"};

@Override



setContentView(R.layout.spinner_layout);

final ImageView imgPais = (ImageView)findViewById(R.id.imgPais);

Spinner combobox = (Spinner) findViewById(R.id.combobox);

ArrayAdapter adaptador = new ArrayAdapter<String>

(this, android.R.layout.simple_spinner_item, paises);

adaptador.setDropDownViewResource(android.R.layout.simple_spinner_item);

combobox.setAdapter(adaptador);

combobox.setOnItemSelectedListener(new

AdapterView.OnItemSelectedListener() {

@Override

public void onItemSelected(AdapterView<?> parent, View view,

int position, long id) {

Competência 05

70

imgPais.setImageResource(imagens[position]);

}

@Override

public void onNothingSelected(AdapterView<?> parent) {

}

});

}

}

Uma observação a ser feita a respeito desse exemplo é que, para exibir a imagem das

bandeiras corretamente, você primeiro deve baixá-las e colocá-las na pasta drawable. Sempre que

você quiser exibir uma imagem no seu app, você pode colocá-la nessa pasta e, para ter acesso a

essa imagem, basta digitar R.drawable.NOME_DA_IMAGEM sem a extensão do arquivo (.jpg, .png,

etc.). No caso, para você conseguir visualizar as diferentes bandeiras do exemplo, você teria que

fazer o download das imagens, colocar na pasta drawable e o nome das imagens teriam que ser

iguais ao nome correspondente aos elementos do array de inteiros.

Veja na figura 15 a seguir como ficou o nosso exemplo:

Figura 15 - Imagem que representa um exemplo da utilização de um Spinner que, ao mudarmos o nome do país, muda também a imagem da bandeira que o representa.

Fonte: o autor.

Competência 05

71

Descrição: a imagem mostra dois prints de uma mesma tela, em ambas existe um texto com o valor Selecionar um país: logo abaixo está um Spinner, também conhecido como ComboBox, que representa um conjunto de opções, no caso um conjunto de países. Na primeira tela está selecionado no Spinner o valor Brasil e abaixo está sendo exibida a bandeira. Na outra imagem está selecionado o país Canada e abaixo está sendo exibida a bandeira canadense.

5.7 ProgressDialog

Você já deve ter visto muitas vezes no momento de abrir um software no carregamento ou no

processo de instalação a seguinte mensagem: “Por favor, aguarde...” ou “Aguarde, essa operação

pode demorar alguns minutos...”. No Android existe uma classe especialmente para isso, a classe

ProcessDialog, filha da classe Dialog.

A seguir veremos um exemplo bastante simples exibindo a mensagem “Por favor, aguarde...”.

ProgressDialog dialog = new ProgressDialog(this);

dialog.setTitle("Título da ProgressBar");

dialog.setMessage("Por favor, aguarde...");

dialog.setIndeterminate(true);

dialog.setCancelable(true);

dialog.show();

Colocando esse trecho de código acima, no onCreate da sua activity, será exibida uma janela de

progresso com o título e mensagem informados. A classe ProgressDialog é bastante usada quando

se deseja fazer um processamento que não se sabe quanto tempo irá durar, ou seja, o tempo é

indeterminado. Por exemplo, imagine que você queira que a sua aplicação exiba/carregue ou faça

um download de um documento PDF ou de uma imagem que se encontra na internet (o tempo de

resposta de requisições feitas utilizando a internet é indeterminado, depende muito da rede do

usuário). Enquanto esse processo está sendo executado, um alerta de progresso deve ser exibido na

tela (OBS: caso você esteja fazendo alguma operação que use a internet é necessário adicionar a

permissão no arquivo AndroidManisfest.xml).

Competência 05

72

Figura 16 - Exemplo da utilização do componente ProgressDialog Fonte: o autor.

Descrição: a imagem mostra uma tela com um ProgressDialog sendo utilizado. No fundo da tela, por trás, existe o texto “EXECUTANDO UM PROGRESS_DIALOG” e por cima está o ProgressDialog, que é uma caixa com o título “Título da ProgressBar”, e abaixo está o texto Por favor, aguarde...

5.8 Toast

A classe Toast é usada para exibir alertas para o usuário, inclusive, nós já a usamos algumas vezes

aqui no nosso material para exibir algumas mensagens de feedback para o usuário. Normalmente,

os alertas exibidos duram pouco tempo, para isso utiliza-se a constante Toast.LENGTH_SHORT. Para

o alerta demorar mais, pode-se utilizar a constante Toast.LENGTH_LONG. A forma mais simples de

exibir um alerta é usando o método Toast.makeText(contexto, mensagem, tempo_de_duração).

A seguir veremos um exemplo da utilização da classe Toast:

Toast alerta = Toast.makeText(this, "Texto da mensagem", Toast. LENGTH_

LONG);

Esse tipo de alerta é o mais simples possível, caso você queira exibir um alerta mais complexo, com

Competência 05

73

uma interface gráfica mais rebuscada e customizada, você pode desenvolver a sua view e usar o

método toast.setView(view) para especificar a interface que você criou. Observe que o método

setView recebe uma View, e todos os elementos que vimos nesse capítulo e no anterior (o de

gerenciadores de layout) são filhos da classe View.

5.9 Resumo

Nesse capítulo vimos muitos elementos de layout que fazem parte da classe View, contudo, existem

vários outros. O importante é você conhecer os principais e à medida que você for tendo mais

experiência e for necessitando de elementos mais complexos você consultar a documentação ou

buscar outros exemplos e tutorias na internet que ajudem a usar esses novos elementos.

Competência 06

74

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

Importantes

Neste capítulo falaremos sobre um possível banco de dados que podemos usar na nossa

aplicação Android, aprenderemos o conceito de SharedPreferences, o que é e pra que serve e

abordaremos algumas APIs importantes do Android que nos permite visualizar mapas, GPS e enviar

notificação.

6.1 Banco de dados

O Android tem integração com o SQLite que é um banco de dados bastante poderoso e

leve. Ele permite que a aplicação armazene as informações da sua aplicação normalmente. Embora

o armazenamento de informações por intermédio de um banco de dados seja a forma mais comum,

o Android possibilita que você também armazene suas informações em arquivos ou através de

estruturas simples do tipo chave valor.

6.2 SQLite

O SQLite pode ser baixado no site www.sqlite.odrg.

Quando você cria um banco de dados no SQLite ele fica na pasta:

/data/data/nome_do_pacote/databases/

Existem várias formas de se criar a sua base de dados. Você pode utilizar a API do

próprio Android para o SQLite, ou você pode usar um cliente do SQLite como o SQLite Expert

Personal ou qualquer outra ferramenta que se integre com o SQLite e permita você criar a sua base

de dados. Essas ferramentas também possuem interfaces gráficas que auxiliam na manipulação do

seu banco de dados ajudando a fazer select, insert, delete, criação de tabelas dentre outros

comandos, e utilizando o aplicativo do SQLite pelo console do emulador. Para mais detalhes acesse

www.sqlite.org/cli.html.

Por exemplo, para criar uma base de dados com o nome “ex1” e uma tabela chamada

“tbl1” usando o sqlite3, por linha de comando, basta digitar:

http://www.sqlite.odrg/

http://www.sqlite.org/cli.html

Competência 06

75

6.3 Preferências do usuário

Além da utilização do banco de dados para salvar algumas informações do usuário,

também é bastante usada uma classe chamada SharedPreferences. Essa classe funciona como uma

estrutura de dados chamada HaVshTable (ou tabela hash) que é uma estrutura do tipo chave valor.

Os valores armazenados são automaticamente persistidos para uma determinada aplicação. Caso a

aplicação seja encerrada e aberta posteriormente os valores armazenados continuaram salvos e

serão recuperados na próxima execução da sua aplicação.

Para recuperar a classe SharedPreferences basta chamar o método

getSharedPreferences (preferencia, modo). Vamos ver como fazer para armazenar as informações

no sharedPreferences e como recuperar essas informações.

O exemplo a seguir mostra como recuperar a classe SharedPreferences e como

recuperar o atributos “status”, caso não tenha sido atribuído, o valor padrão será false.

SharedPreferences sp = getSharedPreferences("NomeDaMinhaApp", 0);

boolean status = sp.getBoolean("status", false);

Para preencher o valor da variável “status”, no caso por ser um booleano, para se

especificar o valor usa-se o método putBoolean, vamos ver um exemplo:

SharedPreferences sp = getSharedPreferences("NomeDaMinhaApp", 0);

SharedPreferences.Editor editor = sp.edit();

editor.putBoolean("status", true);

editor.commit();

Competência 06

76

Note que no final existe o método commit(). Esse método é usado para efetuar a

modificação dos valores da classe SharedPreferences. Sem esse método as modificações não serão

aplicadas. Nesses dois exemplos foi mostrado como recuperar e salvar uma variável do tipo

booleano (true ou false), contudo você poderia salvar e recuperar variáveis de outros tipos como

mostra a figura 17.

Figura 17 – Seleção do método putBoolean.

Fonte: o autor. Descrição: a imagem mostra como selecionar o método putBoolean que o SharedPreferences utiliza, além de outros

disponíveis.

Mesmo que você encerre a aplicação com valores de SharedPreferences já ajustados,

essas informações não serão perdidas, elas permanecem no aparelho e, quando a aplicação for

reiniciada, elas irão conter os valores salvos anteriormente.

Imagine que você tem uma aplicação como mostra a figura 18:

Figura 18 – Seleção da opção Orange. Fonte: o autor.

Descrição: a imagem mostra como selecionar a opção Orange através do CheckBox.

Se no evento de clique do checkbox você salvar o status de clicado ou não na sua

SharedPreference, quando você fechar a aplicação e abrir novamente ele vai ter essa informação

salva, no caso, o checkbox já viria marcado. É bastante comum quando você abrir uma aplicação

Competência 06

77

você já vir logado, não é necessário você logar toda vez, pois muitas aplicações armazenam ou um

arquivo com um token de autenticação ou armazenam esse token no seu sharedPreferences e esse

token é usado nas demais requisições e validam o usuário logado. Esse armazenamento de token de

autenticação é uma prática bastante difundida, pois evita que sejam armazenados o login e senha

do usuário por questões de segurança.

6.4 API de Mapas

Existem muitas aplicações que usam mapas e chamam bastante a atenção dos usuários.

Essas aplicações são geralmente integradas com o Google Maps e algumas utilizam, inclusive,

recursos de GPS do dispositivo.

Com a utilização da API do Google Maps para Android é possível dar zoom no mapa e

escolher o tipo da visualização, se é rua ou satélite. É possível também desenhar imagens de

marcadores informando a localização de objetos ou mesmo do usuário na tela.

Para desenhar um mapa na tela utiliza-se a classe MapView (V1 da API de mapas,

descontinuado em dezembro de 2012), que é uma subclasse de View. Para baixar essa API é

necessário abrir o Android SDK Manager e fazer o download de um pacote chamado de Google

APIs. Ao fazer isso, você já pode utilizar a classe MapView no seu XML de layout.

Na V2 da API de mapas para fazer uso das suas funcionalidades é preciso baixar o pacote

do Google Play Services que se encontra também no Android SDK Manager. Além disso, é preciso

configurar o AndroidManifest.xml para dar acesso à internet e para receber as informações e os

dados da API de mapas. Após o registro das permissões, é preciso obter a chave dos mapas no

Google Cloud Plataform, onde o usuário obtém uma chave usada pelo Google para identificar qual

aplicação está requisitando as informações do mapa. Sem essa chave o mapa não é exibido.

6.5 GPS

A API de GPS utiliza o hardware do dispositivo para informar a localização do usuário.

Para utilização da API é preciso adicionar as permissões ACCESS_FINE_LOCATION e

ACCESS_COARSE_LOCATION no arquivo AndroidManifest.xml.

Para obter a localização do usuário através do GPS, basta implementar a interface

LocationListener na mesma activity que você está utilizando o mapa. Existem vários métodos nessa

Competência 06

78

interface, mas de um modo geral o método onLocationChanged(location) é o mais usado, ele é

disparado quando a localização do usuário muda.

6.6 Resumo

Neste capítulo, vimos diferentes formas de armazenar informações no Android e vimos

diferentes APIs que podem ser usadas nos mais diversos tipos de aplicações. Existem muitas outras

APIs, aqui só vimos algumas delas como possibilidades de enriquecermos ainda mais nossas

aplicações android, pois é importante saber que elas existem para caso você precise no futuro,

desta forma você já sabe como procurar e saber que existe algo que possa suprir sua necessidade

naquele momento.

Competência 07

79

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

Neste capítulo, veremos os passos necessários para publicar um aplicativo na loja do

Google, a famosa Google Play (play.google.com).

7.1 Versionamento da sua app

A primeira coisa que você tem que fazer antes de publicar o seu aplicativo é definir ou

atualizar a sua versão no arquivo AndroidManifest.xml da seguinte forma:


<manifest xmlns:android="http://schemas.android.com/apk/res/android"

package="com.example.gilsondeoliveira.publishingapp"

android:versionCode="1"

android:versionName="0.0.1-beta">

<application

android:allowBackup="true"

android:icon="@mipmap/ic_launcher"


android:supportsRtl="true"

android:theme="@style/AppTheme">

<activity



android:theme="@style/AppTheme.NoActionBar">

<intent-filter>

<action android:name="android.intent.action.MAIN" />

<category android:name="android.intent.category.LAUNCHER"

/>

</intent-filter>

</activity>

</application>

</manifest>

A propriedade versionCode é utilizada para atualizar a versão da aplicação no Google

Play, seu número deve ser sempre superior ao anterior. Já a tag android:versionName indica ao

Competência 07

80

usuário qual a versão da aplicação que ele possui instalada. Dessa forma, o usuário pode ter uma

versão anterior à versão da loja e ele pode identificar essa desatualização pelo nome da versão

apresentado através da tag versionName.

Caso você esteja usando o Android Studio, existe um arquivo chamado build.gradle que

fica em Gradle Scripts que contém as configurações de build da sua APK, nele, assim como no

AndroidManifest.xml você também pode definir o versionCode e o versionName da sua aplicação.

Existindo esse arquivo (no caso de você estar usando o Android Studio), ele tem prioridade sobre as

configurações de build do projeto, ou seja, caso você defina o versionName e versionCode no

AndroidManifest, mas o seu projeto também tenha o arquivo build.gradle, as informações que

serão usadas serão as informações contidas no build.grade, como mostra a figura 19. A seguir,

veremos onde fica esse arquivo na estrutura de um projeto criado pelo Android Studio e veremos

também o seu conteúdo, como mostra a figura 20.

Figura 19 - Estrutura de um projeto Android criado pelo Android Studio e localização do arquivo build.gradle

Fonte: o autor. Descrição: a imagem mostra a estrutura de pastas de um projeto em Android criado no Android Studio e mostra onde o arquivo build.gradle está localizado.

Competência 07

81

Figura 20 - Nome da versão e do código especificados no arquivo gradle.build Fonte: o autor.

Descrição: a imagem mostra o conteúdo do arquivo gradle.build e está destacando o valor dos atributos versionCode que está igual a 1 e o valor do atributo versionName que está igual a “1.0”.

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

Outra configuração importante a que o desenvolvedor deve atentar na hora de gerar

uma build ou versão da sua aplicação é a compatibilidade da versão que ele deseja que a aplicação

rode. Dessa maneira, existe uma propriedade chamada minSdkVersion que especifica a menor

versão que a aplicação vai suportar, ou seja, é a versão a partir da qual a sua aplicação pode ser

instalada. Se a versão do Android for inferior a ela, a Google Play não vai permitir que o usuário

instale a aplicação. Existe também o atributo targetSdkVersion que especifica a última versão que a

sua aplicação pode ser instalada. Os exemplos a seguir mostram como especificar o minSdkVersion

e targetSdkVersion no AndroidManisfest e no arquivo build.gradle, respectivamente exibidos na

figura 21.

Competência 07

82

<manifest

...>

...

<uses-sdk android:minSdkVersion="10" android:targetSdkVersion="21" />

</manifest>

Figura 21 - Especificar as propriedades minSdkVersion e targetSdkVersion no arquivo build.gradle Fonte: o autor

Descrição: imagem do conteúdo do arquivo build.gradle destaca o valor dos atributos minSdkVersion e targetSdkVersion que estão com os valores 15 e 23 respectivamente.

7.3 Assinando a aplicação com um certificado digital

Para instalar a aplicação em um celular real ou no emulador é preciso que a sua

aplicação esteja assinada digitalmente. Quando você compila usando o modo Debug esse processo

é feito automaticamente pela sua IDE, seja ela o Eclipse ou Android Studio, de forma transparente.

Contudo para assinar uma APK para ir para a Google Play é necessário você gerar o seu próprio

certificado através do JDK, dessa forma você terá a sua chave privada e com ela poderá assinar APK

durante o build.

Competência 07

83

Existem vários artigos na internet mostrando como assinar a sua APK, seremos bem

objetivos aqui. Para gerar o seu certificado você precisa rodar um comando usando uma ferramenta

do Java chamada keytool. Essa ferramenta encontra-se na pasta bin da JDK que está instalada no

seu computador, por exemplo, C:\Program Files\Java\jdk1.8.0_101\bin, lá você encontra um

arquivo chamado keytool.exe. Abra o prompt de comando do Windows ou o Terminal do Linux ou

do seu Mac, e vá até essa pasta. Quando chegar nesse diretório digite o seguinte no terminal:

keytool –genkey –v –keystore nome_da_sua_chave.keystore –alias

nome_da_sua_chave –keyalg RSA –validity 10000

Observação: lembre-se de executar o terminal como administrador do sistema, pois a

chave será criada na mesma pasta. E por ser uma pasta do sistema, se você executar o terminal

normalmente pode ser que dê um erro de permissão negada ao tentar criar a chave.

Ao digitar o comando para a criação da chave privada, além de ser pedida uma senha

para o seu certificado (certifique-se de que você se lembrará dessa senha posteriormente), é pedida

uma série de outras informações como seu nome, unidade organizacional, sua empresa, localidade,

dentre outras, de acordo com a imagem abaixo. Ao final desse processo o seu certificado é criado.

Observe este processo na figura 22.

Competência 07

84

Figura 172 - Exemplo de como executar o comando e preencher as informações para geração de um certificado para assinar a APK Android.

Fonte: o autor Descrição: a imagem mostra o prompt do Windows, onde foi digitado o comando para a geração do certificado e as

demais perguntas que se seguem para que o certificado seja criado com sucesso.

Se você tiver usando o Android Studio, existe uma forma mais amigável de gerar esse

certificado. Basta ir no menu clicar em Build e depois em Generate Signed APK... Irá abrir uma

janela como a da figura 23:

Figura 183 - Gerando um certificado pelo Android Studio

Fonte: o autor. Descrição: a imagem mostra a tela Generate Signed APK do Android Studio com todos os campos em branco antes do

certificado ser criado.

Basta você clicar no botão Create new... e preencher as informações e seu certificado

será criado.

Agora que temos a nossa chave privada podemos assinar a nossa aplicação.

Competência 07

85

7.4 Assinando a aplicação para publicá-la no Google Play

Após criar o certificado, basta usá-lo para assinar a sua APK. Mas como fazer isso? Para

assinar a sua APK usando o certificado que você criou, basta importá-lo no Android Studio clicando

no botão Choose existing..., digitar a sua senha e gerar a sua APK assinada clicando no botão Next,

como exibido na figura 24.

Figura 194 - Assinando APK com um certificado existente Fonte: o autor.

Descrição: a imagem mostra a tela Generate Signed APK do Android Studio depois do certificado ser adicionado com todas as informações preenchidas.

Quando você clicar no botão Next vai aparecer uma janela pedindo para você informar

o local onde você deseja que a sua APK assinada seja gerada, ao final do processo basta clicar em

Finish como mostra a figura 25.

Competência 07

86

Figura 205 - Processo final para geração da sua APK assinada

Fonte: o autor Descrição: a imagem mostra a tela Generate Signed APK no seu estágio final, com o Build Type com

o valor release selecionado.

7.5 Publicando a sua aplicação na Google Play

Para publicar a sua aplicação na Google Play é um processo bem simples, basta entrar

no site https://play.google.com/apps/publish/. Se você já estiver logado já abrirá a página da

figura a seguir, caso contrário você precisará logar com a conta do Google, a qual a sua aplicação

estará associada. Veja a figura 26 a seguir.

https://play.google.com/apps/publish/

Competência 07

87

Figura 216 - Tela de aceitação do contrato como desenvolvedor da Google Play

Fonte: o autor. Descrição: a imagem mostra uma tela com informações da conta da Google do usuário que está logado, com o valor a ser cobrado pela licença de desenvolvedor, com os termos de uso e um botão para continuar o pagamento.

São quatro passos para concluir o seu cadastro de desenvolvedor, o primeiro é fazer o

login com uma conta Google, depois aceitar os termos de uso do contrato (disponível em

https://play.google.com/about/developer-distribution-agreement.html), pagar 25 dólares e, por

fim, fornecer os detalhes da conta como é exibido na figura 27.

Figura 227 - Tela de pagamento, basta inserir o cartão de crédito e pagar 25 dólares.

Fonte: o autor Descrição: a imagem mostra a tela com as informações do cartão de crédito juntamente com o valor da licença para o

pagamento.

Depois do pagamento confirmado e de fornecer as suas informações você já pode fazer

a publicação da sua aplicação. Basta preencher um formulário com uma breve descrição da sua

aplicação, enviar alguns screenshots. Depois de preencher as informações do APP basta fazer o

upload da APK assinada, escolher a categoria da aplicação e informar se ela é paga ou gratuita (em

aplicações pagas o Google Play fica com 30% do valor da aplicação por transação e o desenvolvedor

com os 70% restantes).

https://play.google.com/about/developer-distribution-agreement.html

Competência 07

88

Depois de publicar a aplicação ela será disponibilizada quase que imediatamente na

Google Play e estará pronta para ser instalada. Lembre-se de que a cada nova versão da aplicação

que você subir é preciso incrementar os parâmetros do versionCode e do versionName, como falado

anteriormente. Assim, os usuários serão notificados sobre a existência de uma nova versão e que

eles podem fazer a atualização quando desejarem.

Conclusão

89

Conclusão

Finalizamos a disciplina de Android avançado do nosso curso. O objetivo desse curso foi

mostrar uma visão mais detalhada e aprofundada dos assuntos já abordados na disciplina básica de

Android, além de mostrar novos conceitos.

Alguns conceitos aqui foram abordados de forma bastante detalhada e aprofundada

como Activity e Intent, por exemplo, já outros foram abordados de forma mais superficial para você

saber que existe e quando alguém falar com você ou você precisar de algo você já saber como

pesquisar.

Muito do que aprendemos aqui requer dedicação e prática, pois é preciso entender o

conceito e praticá-lo para saber e ver com funciona. Existem muitos tutoriais na internet e bons

livros como o “Google Android: aprenda a criar aplicações para dispositivos móveis” de Ricardo

Lecheta, que é espetacular tanto no que se refere ao conteúdo quanto à didática.

Caso algum conceito não tenha ficado muito claro, volte e o releia, ou procure outra

fonte para entendê-lo e amadurecê-lo. É sempre bom você ter mais de um material de estudo, pois

caso você não entenda da forma que um professor escreveu um determinado conceito pode ser

que outro escreva de forma mais clara, numa linguagem mais natural.

Lembre-se de quanto mais você praticar e exercitar, mais o trabalho irá parecer fácil e

natural e mais experiente você ficará. Não perca tempo, pratique e durante esse processo divirta-

se!

Um grande abraço e boa sorte! =)

Referências

90

Referências

LECHATA, Ricardo R. Google Android: aprenda a criar aplicações para dispositivos móveis com o Android

SDK. São Paulo: Novatec, 2015.

Minicurrículo

91

Minicurrículo do Professor

Gilson de Oliveira

É formado em Ciência da Computação pela Universidade Federal de

Pernambuco, com mestrado em Ciência da Computação pela UFPE na

área de sistemas distribuídos. Atualmente é analista de sistemas senior

na empresa TECON Suape. Possui experiência com diversas tecnologias

(Android, Objective C, Java Web, .NET, AngularJS, dentre outras) e

plataformas (Desktop, Web, Mobile).

Documents

Programação para Dispositivos Móveis · ambiente de desenvolvimento integrado e se refere a ferramentas de desenvolvimento como Eclipse ou Android Studio, por exemplo) e instalar