Curso de Android Básico

Sumrio
Introduo.............................................................................................................. 2
Arquitetura............................................................................................................... 3
Google Play.............................................................................................................. 6
Montando o Ambiente.............................................................................................. 8
Instalao do SDK do Java........................................................................................ 8
Configurando o Java........................................................................................... 10
Android SDK........................................................................................................... 12
Instalando o Android SDK....................................................................................... 13
SDK Manager.......................................................................................................... 14
Primeiro Exemplo Android................................................................................ 18
Primeiro Exemplo Android................................................................................ 22
Entendendo o Projeto Android................................................................................ 30
Executando o projeto............................................................................................. 33
Processo de execuo do projeto...........................................................................39
Adicionando novos recursos................................................................................... 42
Adicionando recursos diretamente no xml.............................................................43
Adicionando recurso no modo design....................................................................44
Adicionando Widgets aplicao...........................................................................46
TextView................................................................................................................. 47
Executando o projeto Android................................................................................ 50
Trabalhando com eventos...................................................................................... 51
Adicionando Eventos.............................................................................................. 56
Associando o evento ao boto............................................................................... 58
Criando uma nova tela....................................................................................... 60
2 Criando um novo arquivo de layout..................................................................61
3 Criando a classe Java........................................................................................ 65
4 Exibindo a nova tela......................................................................................... 69
Executando o projeto para visualizar a nova tela...................................................71
Voltando para a tela anterior.................................................................................. 72
Executando o projeto............................................................................................. 73
Ciclo de vida das Activities............................................................................... 74
Entendendo o ciclo de vida............................................................................... 76
Layouts................................................................................................................. 77
Layouts................................................................................................................. 79
TableLayout............................................................................................................ 81
Exemplo de TableLayout......................................................................................... 83
Unidades de medida utilizadas no Android....................................................85
Resoluo do Emulador.......................................................................................... 87
RelativeLayout....................................................................................................... 91
FrameLayout.......................................................................................................... 92
ScrollView............................................................................................................... 94
Usando Widgets de Seleo................................................................................... 95
Exemplo de ListView.............................................................................................. 97
Identificando o item selecionado..........................................................................100
CheckBox............................................................................................................. 102
RadioButton......................................................................................................... 105
Spinner................................................................................................................. 109
Tipos de Recursos................................................................................................ 111
Adicionando um recurso de cor......................................................................113
Recursos Grficos................................................................................................. 116
cones de exemplo............................................................................................... 118
Recursos de Menu................................................................................................ 122
Preparando o exemplo......................................................................................... 125
Carregando o menu.............................................................................................. 126
Em execuo........................................................................................................ 127
Programando o menu........................................................................................... 129
Caixa de dilogo................................................................................................... 130
Configurando a janela de confirmao.................................................................133
Submenus............................................................................................................ 134
Dispositivos sem botes fsicos.....................................................................139
Toast..................................................................................................................... 144
Intent................................................................................................................... 146
Intent Filters......................................................................................................... 150
Enviando dados para outra activity......................................................................158
Recebendo dados de outra activity......................................................................161
Intents implcitas disponveis.........................................................................165
Editando um contato............................................................................................ 175
BoadcastReceiver................................................................................................. 177
Notificao......................................................................................................... 189
Introduo
A quantidade de aparelhos celulares vem aumentando, cada vez mais, ao
longo dos anos. Atualmente, o telefone celular o produto de consumo mais
utilizado no mundo.
O nmero de celulares com acesso internet representa mais do dobro de
computadores com o mesmo acesso. E isso s tende a aumentar na medida
em que os pases em desenvolvimento atualizam seus aparelhos por modelos
mais recentes.
Em mercado to promissor, no restam dvidas que inovaes nessa rea so
inevitveis.
Tendo como motivao principal a inovao na rea de telefonia celular, vrias
empresas do ramo de telefonia e tecnologia, com o apoio do Google, criaram
uma parceria que deu origem Open Handset Alliance OHA.
Open Handset Alliance

A Open Handset Alliance um grupo de empresas que se uniram para
acelerar a inovao nos dispositivos mveis. Muitos acreditam que o Google,
por ser a empresa lder dos projetos, o nico a investir nos projetos do grupo.
A inteno inicial da organizao era construir um sistema operacional de
cdigo aberto, onde qualquer software instalado no aparelho tivesse o mesmo
privilgio que os aplicativos criados ou licenciados pelo fabricante, sendo
possvel a total integrao e customizao entre sistemas e aparelhos.
O primeiro software que surgiu desse conjunto de empresas foi o Android,
gerenciado e mantido pela OHA.
Voc
pode
conhecer
mais
site: http://www.openhandsetalliance.com/
sobre
essa
aliana
no
O Android um sistema operacional mvel completo e aberto, desenvolvido

com base no sistema operacional Linux.
Ele foi desenvolvido com a inteno de permitir aos desenvolvedores criar

aplicaes mveis que pudessem tirar total proveito do que um aparelho mvel
pudesse oferecer. Por exemplo, uma aplicao pode apelar para qualquer
funcionalidade do telefone como efetuar chamadas, enviar mensagens de
texto ou utilizar a cmera o que permite aos desenvolvedores adaptarem e
evolurem constantemente essas funcionalidades.
Por ser open source, pode ser adaptado a fim de incorporar as novas
tecnologias medida que forem surgindo. A plataforma sempre estar em
evoluo, j que a comunidade trabalha em conjunto para construir aplicaes
mais inovadoras.
Apesar de ter sido construdo com base no Linux, ele no possui windowing
system nativo, suporte a glibc ou algum dos conjuntos de padres
apresentados em determinadas distribuies Linux.
Uma dvida comum quanto segurana do sistema operacional. Voc deve
estar se perguntando: j que qualquer um pode modificar os componentes, o
que impede que algum faa um software malicioso e acesse informaes
pessoais do seu dispositivo? Bem, o Android conta com um sistema de
segurana muito forte. Por ser executado , todas as vezes que um aplicativo for
instalado em um aparelho Android, ser criado um novo usurio Linux para
aquele aplicativo, com diretrios que sero usados pelo aplicativo, mas
somente por aquele usurio Linux. Como os aplicativos ficam completamente
isolados uns dos outros, para qualquer tentativa de acessar informaes de
outro aplicativo, ser necessrio ter explicitamente a autorizao do usurio,
podendo ser negada ou autorizada a instalao do aplicativo, atravs dos
mecanismos de permisso.
Cada processo da aplicao no Android considerado uma sandbox. S ser
possvel acessar outras aplicaes caso as permisses sejam explicitamente
declaradas o que necessrio para que possam ser conhecidas desde o
momento da instalao. Nada ir fazer com que sejam alteradas, depois disso.
Toda aplicao Android precisa ser assinada com um certificado cuja chave
privada mantida por seu desenvolvedor. No necessrio que este
certificado seja assinado por uma autoridade de certificao, pois funciona
somente para estabelecer relaes de confiana entre as aplicaes.
Para desenvolver aplicaes para o Android utilizado o kit de
desenvolvimento Android SDK, que disponibiliza as ferramentas e APIs
necessrias, utilizando o Java como linguagem.
Arquitetura
Na imagem abaixo voc pode ver como estruturada a arquitetura do Android:
Ele
possui
as
camadas: Applications, Application Frameworks, Libraries, Android Runt
ime e Linux Kernel.
Applications
Acima de todas as camadas est localizada a de aplicativos (Applications), na
qual se encontram todos os aplicativos fundamentais (escritos em Java) do
Android, como: um cliente de e-mail, mapas, navegadores, calendrios,

programas SMS, entre outros.
Isso significa que, para desenvolver programas para a plataforma Android, os
aplicativos devem ser criados em Java para serem executados na mquina
virtual Dalvik. Lembrando que uma aplicao no precisa obrigatoriamente ser
escrita para o Android, j que o Java possui grande portabilidade. Outras
aplicaes escritas em Java podem ser incorporadas ao Android.
Application Framework
Na camada do framework (Application Framework) esto todas as APIs e
recursos utilizados pelos aplicativos: as classes visuais que incluem listas,
grades, caixas de texto, botes e at um navegador web embutido View
System (componentes utilizados na construo de aplicativos); provedor de
contedo (Content Provider) que possibilita, determinada aplicao,
acessar informaes de outra aplicao, ou at compartilharem informaes,
possibilitando a troca de informaes entre aplicativos e gerenciadores de
recursos, gerenciador de localizaes (GPS e Cell ID), gerenciador de
notificao (fornece informaes sobre eventos que ocorrem no dispositivo), de
pacotes e de atividade que controla todo o ciclo de vida da aplicao e o
acesso e navegao entre as aplicaes.
Todos os conjuntos de componentes disponveis na plataforma Android
possuem pleno acesso s APIs utilizadas pelo ncleo da plataforma. Esta
arquitetura foi projetada para simplificar a reutilizao de componentes, onde
qualquer aplicao pode usar recursos de outra, desde que respeite s
restries de segurana.
Libraries
A camada de bibliotecas (Libraries) carrega consigo um conjunto de
bibliotecas C/C++ utilizadas pelo sistema includas nesse conjunto a
biblioteca C padro (Libc) e possui ainda aquelas bibliotecas das reas de
multimdia, visualizao de camadas 2D e 3D, funes para navegadores web,
funes para grficos, funes de acelerao de hardware, renderizao 3D,
fontes bitmap e vetorizadas e funes de acesso ao banco de dados SQLite.
Tais recursos esto disponveis no framework para o desenvolvimento de
aplicativos.
Android Runtime
A pequena camada do ambiente de execuo (Android Runtime) uma

instncia da mquina virtual Dalvik, criada para cada aplicao executada no
Android. A Dalvik uma mquina virtual com melhor desempenho, maior
integrao com a nova gerao de hardware e projetada para executar vrias
mquinas virtuais paralelamente. Foi projetada para funcionar em sistemas
com baixa frequncia de CPU, pouca memria RAM disponvel e sistema
operacional sem espao de Swap. Alm disso, otimizada para o consumo
mnimo de memria, bateria e CPU.
O Libraries Core inclui um grupo de bibliotecas que fornece a maioria das
funcionalidades disponveis nas principais bibliotecas da linguagem Java, como
estruturas de dados, acesso a arquivos, acesso a redes e grficos.
Aplicaes escritas em Java so compiladas e executadas usando a Mquina
Virtual Dalvik, desenvolvida para uso em dispositivos mveis, o que permite
que programas sejam distribudos em formato binrio (bytecode) e possam
rodar em qualquer dispositivo Android, independente do processador utilizado.
Apesar de as aplicaes Android serem escritas em Java, elas no rodam na
mquina virtual do Java (JVM).
Linux Kernel
Utiliza a verso 2.6 do kernel do Linux para os servios centrais do sistema,
tais como segurana, gesto de memria, gesto de processos, pilha de
protocolos de rede e modelo de drives. O kernel tambm atua como uma
camada de abstrao entre hardware e o resto da pilha de software. Um
acessrio interessante o Binder (IPC), responsvel por obter e enviar para a
aplicao requerente a interface de servio da aplicao requerida,
possibilitando a Comunicao Inter-processos (IPC).
Google Play
O Google Play uma evoluo da Android Market, antiga loja de aplicativos
Android desenvolvida pelo Google. Agora no Google Play, alm de aplicativos,
tambm possvel comprar/baixar livros (e-book), filmes, msicas, dispositivos
e acessrios. Disponvel no link:http://play.google.com/:
Algumas opes da loja esto disponveis apenas em alguns mercados.

Dentro
da
loja,
no
caminho https://play.google.com/apps/publish,
o
desenvolvedor pode registrar e publicar seus aplicativos, pagando uma taxa de
25 dlares:
Android Developers
O site Android Developers (http://developer.android.com/) contm todas as
informaes para oferecer suporte e auxiliar a desenvolver o Android:
Montando o Ambiente
Para desenvolver aplicaes Android utilizada a linguagem Java. Qualquer
editor pode ser utilizado para desenvolver uma aplicao (at o bloco de notas,
compilando na linha de comando do SO). Neste curso ser usado o Eclipse, que
a IDE recomendada pelo Google.
Alm dos diversos recursos do Eclipse, h um plugin especfico para o
desenvolvimento Android que aumenta a produtividade no desenvolvimento.
O Google recomenda os seguintes requisitos de software e hardware:
Sistemas Operacionais
Windows XP ou superior
Mac OS X 10.5.8 ou superior
Linux
Software
JDK6 ou JDK7
Eclipse 3.6.2 (Helios) ou superior.
Android Developer Tools Plugin
Hardware
Espao livre em disco de 1 GB aproximadamente.

Memria mnima de 1 GB.
Para configurar o ambiente, voc pode seguir esta ordem:
12345-
Instalao
Instalao
Instalao
Instalao
Instalao
do
do
do
da
do
SDK do Java.
Eclipse.
SDK do Android.
plataforma do Android.
Plugin Android para Eclipse.
Obs: Para evitar qualquer tipo de conflito nos programas que sero instalados,
desinstale qualquer verso antiga dos softwares listados. Ou utilize o ADT
Bundle disponibilizado pelo Google, que traz as etapas 2 a 5 acima j
configuradas. Essa opo adotada neste curso.
Instalao do SDK do Java

Para
efetuar
o
download
do
SDK
do
Java,
acesse
este
endereo: http://www.oracle.com/technetwork/java/javase/downloads/index.ht
ml:
Sempre baixe a ltima verso do JDK primeiro cone na imagem acima. Ao

clicar no cone, a imagem abaixo ser apresentada:
Aceite os termos e baixe a verso de acordo com o seu sistema operacional. A

instalao no requer uma srie complicada de passos, basta ir avanando at
finalizar.
Configurando o Java
Antes de instalar o SDK do Android, ser necessrio configurar algumas
variveis de ambiente do Windows, incluindo a varivelJAVA_PATH, que ser
utilizada pelo SDK do Android.
Para o Windows 8, Windows 7 e Windows Vista, abra o Painel de Controle:
Clique na opo Sistema e Segurana (System and Security):
Nessa tela, selecione a opo Sistema (System):
Nessa tela, clique na opo Configuraes avanadas do sistema (Advanced

system settings) no lado esquerdo da imagem acima, para exibir a seguinte
caixa de dilogo:
Nessa caixa de dilogo, clique no boto Variveis de Ambiente (Environment

Variables):
Agora, para o usurio local (o primeiro box), adicione trs variveis de

Ambiente.
Clique no primeiro boto Novo...:
Na caixa de dilogo que surgir, adicione a varivel JAVA_PATH:
Varivel: JAVA_PATH
Valor: C:\Program Files\Java\jdk1.7.0_03 (o valor pode variar no seu
computador)
Confira com a imagem acima e clique em OK para criar a varivel:
Android SDK
Para
baixar
o Android
site: http://developer.android.com/sdk/index.html:
SDK acesse
Agora o Google disponibiliza o ADT Bundle, que incluiu o Eclipse com o plugin
ADT instalado, alm do Android SDK, permitindo pular essa etapa do processo.
Clique em Download the SDK:
Leia os termos de uso. Se concordar, marque a opo I have read and...,

selecione a verso do seu sistema operacional e efetue o download do ADT
Bundle:
Instalando o Android SDK

Aps efetuar o download, desempacote o arquivo no local da sua preferncia:
Note que dentro da pasta esto duas pastas e o SDK Manager:
Nesse pacote tudo j est configurado, no sendo preciso fazer mais nada.
Basta abrir o Eclipse para iniciar o desenvolvimento da aplicao.
Porm, antes de fazer isso conhea o SDK Manager, que a ferramenta mais
importante do SDK do Android.
SDK Manager
O SDK Manager permite gerenciar as vrias verses disponveis do SDK do
Android. Para inici-lo, execute o arquivo SDK Manager.exe, presente na
pasta do pacote:
A aplicao abaixo ser aberta:
Ela lista todas as ferramentas disponveis para o SDK, bem como todas as
verses de SDK do Android para baixar.
Note que a verso 4.2 do Android j est instalada. No momento, essa a
verso mais atual. Mas para desenvolver uma aplicao para uma plataforma
especfica como, por exemplo, a 2.3, necessrio instalar essa verso do SDK.
Selecione-a:
Em seguida, clique no boto Install X package:
Esse boto sempre ir exibir a quantidade de pacotes a serem instalados. Ao

clicar nele, a caixa de dilogo abaixo ser aberta:
Os pacotes a serem instalados so detalhados e a licena de uso exibida.

Para instal-lo, necessrio aceitar os termos de uso. Clique em Accept em
cada pacote ou Accept All para todos:
Em seguida, clique em Install para instalar os pacotes:
Os pacotes sero baixados e instalados:
Primeiro Exemplo Android

Primeiro preciso executar o Eclipse. Basta executar o aplicativo eclipse.exe,
presente na pasta eclipse do bundle:
Ao ser executado, a tela abaixo ser exibida:
Nela, selecione a pasta de trabalho (o local onde os projetos sero criados), e

clique em Ok. O Eclipse ser carregado e aberto:
Por estar tudo configurado, voc j pode criar o projeto.

Como mostra a pgina de Boas-vindas (que pode ser fechada), para criar um
projeto Android voc deve selecionar a opo no menu File -> New ->
Android Application Project, conforme mostra a imagem a seguir:
A tela New Android Application ser aberta:
Nessa tela, preencha as seguintes informaes:
Em Application Name digite Primeiro Projeto (esse nome ir

identificar a aplicao, ou seja, ser com ele que a aplicao ser apresentada
aos usurios).
Em Project Name digite PrimeiroProjeto (esse nome, alm de
identificar o projeto, ser o nome da pasta onde ele ser criado).
Em Package name entre com br.com.treinaweb.parte1 (esse ser o
nome do pacote Java, das classes da aplicao. por isso que ele segue as
mesmas regras do Java; ou seja, o domnio ao contrrio).
Em Minimum Required SDK selecione API 9: Android 2.3 (esse o
SDK mnimo para executar a aplicao).
Em Target SDK selecione API 17: Android 4.2 (esse ser o SDK ideal
para a utilizao da aplicao).
Em Compile With selecione API 17: Android 4.2 (o SDK utilizado para
compilar a aplicao. Ele deve ser igual ou superior ao SDK definido em Target
SDK).
Em Theme selecione Holo Light with... (Esse ser o tema da aplicao

e os widgets j sero formatados para esse tema).
Obs: Se for necessrio modificar a plataforma no futuro, basta clicar com o
boto direito do mouse sobre o projeto, no Package Explorer, e selecionar a
opo Properties, depois selecionar Android e marcar a plataforma desejada.
Defina os valores, conforme a imagem abaixo:
Clique em Next:
Primeiro Exemplo Android

Primeiro preciso executar o Eclipse. Basta executar o aplicativo eclipse.exe,
presente na pasta eclipse do bundle:
Ao ser executado, a tela abaixo ser exibida:
Nela, selecione a pasta de trabalho (o local onde os projetos sero criados), e

clique em Ok. O Eclipse ser carregado e aberto:
Por estar tudo configurado, voc j pode criar o projeto.

Como mostra a pgina de Boas-vindas (que pode ser fechada), para criar um
projeto Android voc deve selecionar a opo no menu File -> New ->
Android Application Project, conforme mostra a imagem a seguir:
A tela New Android Application ser aberta:
Nessa tela, preencha as seguintes informaes:
Em Application Name digite Primeiro Projeto (esse nome ir

identificar a aplicao, ou seja, ser com ele que a aplicao ser apresentada
aos usurios).
Em Project Name digite PrimeiroProjeto (esse nome, alm de
identificar o projeto, ser o nome da pasta onde ele ser criado).
Em Package name entre com br.com.treinaweb.parte1 (esse ser o
nome do pacote Java, das classes da aplicao. por isso que ele segue as
mesmas regras do Java; ou seja, o domnio ao contrrio).
Em Minimum Required SDK selecione API 9: Android 2.3 (esse o
SDK mnimo para executar a aplicao).
Em Target SDK selecione API 17: Android 4.2 (esse ser o SDK ideal
para a utilizao da aplicao).
Em Compile With selecione API 17: Android 4.2 (o SDK utilizado para
compilar a aplicao. Ele deve ser igual ou superior ao SDK definido em Target
SDK).
Em Theme selecione Holo Light with... (Esse ser o tema da aplicao

e os widgets j sero formatados para esse tema).
Obs: Se for necessrio modificar a plataforma no futuro, basta clicar com o
boto direito do mouse sobre o projeto, no Package Explorer, e selecionar a
opo Properties, depois selecionar Android e marcar a plataforma desejada.
Defina os valores, conforme a imagem abaixo:
Clique em Next:
Nessa tela voc pode definir: se ser criado um cone customizado (Create
custom laouncher icon); se a aplicao j ser criada com uma tela (Create
activity); e se a aplicao ser uma biblioteca que poder ser utilizada em
outros projetos Android (Mark this project as libary). Tambm permitido
modificar o local do projeto, bem como definir se ele ser includo em
um Working set (espaos de trabalho dentro do workspace).
Selecione as opes na tela, conforme indicado na imagem acima e clique
em Next:
Nessa tela voc definir qual ser o template utilizado na criao

da Activity (tela). No caso deste exemplo, utilize a primeira opo
(BlankActivity), conforme a imagem acima. Clique em Next:
Nessa tela, preencha com as seguintes informaes:
Em Activity Name informe Tela1 (esse ser o nome da classe Java da

tela/Activity).
Em Layout Name informe activity_tela1 (esse ser o nome do arquivo
de layout).
Em Navigation Type selecione None (indica o tipo de navegao
utilizada e, por enquanto, no ser utilizada).
Clique em Finish para criar o projeto:
Entendendo o Projeto Android

Observe que no Package Explorer o projeto j foi criado com uma srie de
pastas e arquivos:
A primeira pasta a src; nela ficam contidas as classes em Java. Ao expandi-la,

nota-se que a primeira classe j foi criada:
O nome do pacote foi a informao adicionada na opo Package name, na

criao do aplicativo, e o nome da classe da Activity Name.
D um duplo clique no arquivo Tela1.java para abri-lo; ser exibido o cdigo
abaixo:
Obs: O cdigo pode ser um pouco diferente, dependendo da verso do Android

utilizada na criao do aplicativo.
Para o Android, uma activity nada mais do que uma tela ou UI (User
Interface); por exemplo, uma tela de login onde haver caixas de texto para a
entrada do login e da senha. Toda activity derivada da classe Activity,
como mostrado no exemplo acima.
No altere nada neste no momento.
A segunda pasta a gen; nela ficam as classes em Java que contm as
constantes referentes aos recursos da aplicao. Ela tambm uma classe
criada pelo template e no deve ser alterada manualmente, muito menos os

arquivos que ela contm:
Por exemplo, para fazer referncia

arquivo activity_tela1.xml explicado
inteiroR.layout.activity_tela1,
como
classe Tela1.java anteriormente.
a um arquivo de layout
frente)
usa-se
demonstrado
no
cdigo
(o
o
da
Voc at pode a abrir o arquivo R.java:
A pasta Android 4.2 (o nome pode variar de acordo com a verso do Android)
contm a referncia da biblioteca do Android:
Essa biblioteca contm todos os pacotes e respectivas classes do Android.

A pasta Android Dependencies uma pasta virtual do Eclipse, que lista das
dependncias do projeto. As dependncias so os arquivos.jar adicionados a
ele:
O arquivo android-support-v4.jar contm bibliotecas de apoio, permitindo

referenciar classes no mais suportadas pelo Android, mas que podem ser
utilizadas em uma verso mais antiga.
Na pasta assets podem ser adicionados os recursos extras do projeto. Eles no
so gerenciados automaticamente pelo plugin Android, sendo necessrio
fornecer um nome e um caminho vlidos para todos os recursos que forem
adicionados.
No momento ela no possui nenhum recurso:
Voc aprender a gerenciar os recursos dessa pasta nos prximos cursos.

Na pasta bin adicionada a sada do projeto, ou seja, os arquivos compilados
que sero utilizados para gerar a aplicao:
Executando o projeto
Para executar o projeto, no Package Explorer, clique com o boto direito do
mouse sobre o projeto e selecione a opo Run as > Android Application,
conforme mostra a imagem abaixo:
Se for a primeira vez que voc executa o projeto, o emulador ir demorar

alguns minutos para carregar.
No incio ele apresentar esta tela:
Ela indica que o emulador est sendo carregado. Ao terminar o carregamento,

a seguinte tela ser apresentada:
O emulador semelhante ao celular. Nesse caso necessrio desbloquear o

emulador para exibir a aplicao.
Utilizando o mouse, clique no cadeado:
E o arraste at a lateral:
A aplicao ser exibida:
Obs: No feche o emulador (caso contrrio, voc ter que esperar o

emulador carregar quando for executar o projeto novamente).
Mesmo voc no tendo programado, a mensagem HelloWorld! foi exibida.
Entenda como o projeto foi executado.
Obs: Se ao executar o projeto aparecer esta caixa de texto:
Selecione Yes, monitor logcat and... e clique em OK. A aba LogCat ser
exibida:
Ela funciona como o output do emulador. Todo retorno do emulador

apresentado nessa tela. Isso inclui as mensagens de erro, que so
apresentadas em vermelho. Quando houver um erro, voc poder verificar a
causa, consultando essa aba.
Processo de execuo do projeto
Ao executar o projeto, o primeiro arquivo a ser chamado a classe Tela1, na

pasta src:
Esssa classe estende a classe Activity:

public class Tela1 extends Activity {
Que o equivalente do Android para um frame do swing ou um form do

Windows.
Dentro da classe h o mtodo onCreate:
protected void onCreate(Bundle savedInstanceState) {
Ele ser executado automaticamente assim que a classe for carregada para a
memria.
Dentro do mtodo onCreate chamado o mtodo onCreate da classe-pai (no
caso a classe Activity):
super.onCreate(savedInstanceState);
A palavra-chave super utilizada para referenciar o mtodo da classe-pai.

Logo em seguida, executado o mtodo setContentView:
setContentView(R.layout.activity_tela1);
Ser esse mtodo que, efetivamente, ir criar a apresentao na tela. Observe

que foi passado como parmetro o R.layout.activity_tela1, que nada mais
do que a referncia ao arquivo acitivity_tela1.xml, ou seja, a tela:
Observe o cdigo-fonte do arquivo:
O objeto TextView:
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerHorizontal="true"
android:layout_centerVertical="true"
android:text="@string/hello_world" />
Esse o objeto utilizado para apresentar um texto na tela, definido na

propriedade text do objeto. Note a forma em que ela foi definida:
O valor @string/hello_world se refere informao de outro arquivo de

recursos, que no caso o arquivo string.xml:
Repare na linha:
Adicionando novos recursos

Como j explicado, os recursos podem ser imagens ou textos utilizados pela
aplicao. No momento sero adicionados novos textos no projeto.
Os textos sero includos no arquivo strings.xml da pasta res/values:
Que no momento s possui duas informaes:

<resources>
<string name="app_name">Primeiro Exemplo</string>
<string name="hello_world">Ol Mundo!</string>

<string name="menu_settings">Configuraes</string>
</resources>
Existem duas formas de adicionar recursos nesse arquivo: pela forma grfica
ou pelo cdigo-fonte.
Adicionando recursos diretamente no xml

Para adicionar um novo recurso ao arquivo, basta inserir uma linha entre as
tags <resources> e </resouces>:
<resources>
...
</resources>
Mas tome cuidado porque o arquivo xml diferencia letra maiscula de

minscula e as tags devem estar corretamente formatadas. Para evitar erros
de digitao voc deve utilizar ao mximo a complementao de cdigo. Por
exemplo:
Antes da tag </resources> digite apenas o smbolo de menor (<):
Uma lista suspensa dever aparecer. Caso no aparea, pressione CTRL +

barra de espao para exibi-la:
Ela exibe os recursos disponveis que podem ser adicionados no arquivo. Como
esse um arquivo de recursos string, s essa opo estar disponvel.
Selecione a opo string e comece a digitar a propriedade name, mas digite
apenas a letra n e pressione Ctrl+ barra de espao para exibir as opes
disponveis:
Agora voc pode criar o recurso com possibilidades mnimas de erro. Desta
forma, crie um recurso chamado aluno, conforme o cdigo abaixo:
<resources>
<string name="aluno">Carlos Santos Silva</string>
</resources>
Na parte grfica o processo mais simples e seguro.
Adicionando recurso no modo design

Mude para o modo design, selecionando a aba Resources no rodap do
arquivo:
A seguinte tela ser exibida:
Clique no boto Add...; a caixa de dilogo a seguir ser exibida:
Selecione a opo String e clique em OK:
Agora basta definir o name e o value do recurso, conforme mostra a imagem

abaixo:
Preencha os campos, respectivamente, com curso e Android bsico,

conforme mostra a imagem acima e salve o arquivo (menu File ->Save ou
apenas CTRL + S).
Obs: Recomenda-se utilizar o modo design (imagem acima) que, alm de mais
produtivo, oferece menos chances de gerar erros de digitao.
O arquivo conter os seguintes recursos:
<resources>
<string name="curso">Android Bsico</string>
</resources>
Adicionando Widgets aplicao

Um widget um objeto visual utilizado para a criao da interface da
aplicao. O Android disponibiliza uma srie de widgets prontos como: botes,
caixas de texto, caixas de verificao etc.
O arquivo activity_tela1.xml dentro da pasta res/layout:
o arquivo responsvel pela interface do usurio. D um duplo clique sobre ele

para exibir a seguinte tela:
Observe, na imagem acima esquerda, a Pallete que contm uma aba com
vrios widgets que podem ser adicionados tela.
TextView
Para adicion-los s arrastar o widget da Pallete para a tela. Faa esse
movimento para o widget TextView, que utilizado para apresentar um texto
na tela. O arquivo ficar da seguinte forma:
O TextView o primeiro Widget da categoria Form Wirdgets do Palette.

J para adicionar um recurso existente a esse widget, no caso o recurso
includo no arquivo strings.xml, basta clicar com o boto direito do mouse
sobre o TextView e selecionar a opo Edit Text, conforme indicado na
imagem a seguir:
A janela Resource Chooser ser exibida:
Agora basta selecionar o recurso adequado, que neste exemplo aluno, e

clicar no boto OK:
Observe que o contedo do recurso denominado aluno (Carlos Santos Silva) j

aparece na tela.
Mude para o cdigo-fonte (para o xml):

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".Tela1" >
<TextView
android:layout_centerHorizontal="true"
android:layout_centerVertical="true"
<TextView
android:id="@+id/textView1"
android:layout_alignParentLeft="true"
android:layout_alignParentTop="true"
android:layout_marginLeft="30dp"
android:layout_marginTop="28dp"
android:text="@string/aluno" />
</RelativeLayout>
Observe que este widget semelhante ao widget adicionado pelo plugin, com
apenas duas diferenas: os atributos esto na mesma linha, o que no interfere
em nada; e j foi adicionado o atributo android:id, que utilizado para
identificar o widget via programao (como ser explicado frente).
Voc pode adicionar e alterar widgets diretamente no arquivo, mas a forma
grfica a mais recomendvel para se trabalhar com widgets.
Executando o projeto Android

Execute o projeto para visualizar a alterao:
Repita o procedimento (adicione um TextView e informe o recurso de texto)

para exibir o nome do curso:
Trabalhando com eventos
Primeiramente, abra o arquivos de recursos (strings.xml) e adicione os

recursos msg, texto_nome, botao_proximo, botao_ok e resposta,
conforme o cdigo abaixo:
<resources>
<string name="msg">Digite seu nome abaixo</string>
<string name="texto_nome"></string>
<string name="botao_proximo">Prxima Tela</string>
<string name="botao_ok">OK</string>
<string name="resposta">Resposta:</string>
</resources>
Agora abra o arquivo de layout activity_tela1.xml:
Remova
os
trs TextVeiw e
adicione
um EditText,
um Button e
dois TextView. Organize-os conforme indicado na seguinte imagem:
Obs: O EditText se encontra na categoria Text Fields da Palette:
Qualquer widget dessa categoria um EditText. Cada um customizado para

um objetivo, como: insero de telefone, nome, e-mail, hora e etc.
Dependendo do tipo escolhido, um layout de teclado mostrado. Neste
exemplo, foi utilizado o Person Name (a segunda opo da categoria, utilizada
para nomes).
Altere o texto do primeiro TextView para o recurso msg; vincule o
recurso texto_nome ao
widget EditText;
o
recurso botao_ok ao
widgetButton; e o recurso resposta ao outro TextView. A sua tela ficar igual
imagem abaixo:
Como os widgets sero referenciados no cdigo, necessrio definir os seus

IDs.
Para definir o ID de um widget, clique com o boto direito do mouse sobre o
widget e selecione a opo Edit ID...:
A caixa de dilogo abaixo ser exibida:
Em New id preencha editTextNome, conforme mostra a imagem acima, e

clique em OK para mudar o ID do widget EditText.
Obs: Fique atento ao layout, pois como est sendo utilizado RelativeLayout,
os controles so posicionados em relao ao outro widget da tela. Essa relao
verificada de acordo com o ID do widget. Ento, ao modific-lo, o widget
pode perder a referncia e modificar a sua posio (layouts sero explicados
frente).
Repita o mesmo processo para Button e para os dois TextView, onde os
widgets
tero,
respectivamente,
os
Ids: buttonProximo,textViewMensagem e textViewResposta.
O cdigo-fonte do layout ser semelhante ao cdigo abaixo:
<TextView
android:id="@+id/textViewMensagem"
android:text="@string/msg" />
<EditText
android:id="@+id/editTextNome"
android:layout_alignLeft="@+id/textViewMensagem"
android:layout_below="@+id/textViewMensagem"
android:ems="10"
android:inputType="textPersonName"
android:text="@string/texto_nome" >
<requestFocus />
</EditText>
<Button
android:id="@+id/buttonProximo"
android:layout_alignLeft="@+id/editTextNome"
android:layout_below="@+id/editTextNome"
android:text="@string/botao_ok" />
<TextView
android:id="@+id/textViewResposta"
android:layout_alignLeft="@+id/buttonProximo"
android:layout_below="@+id/buttonProximo"
android:text="@string/resposta" />
</RelativeLayout>
Salve o arquivo de layout e abra o Activity Tela1:

package br.com.treinaweb.parte1;
import android.os.Bundle;
import android.app.Activity;
import android.view.Menu;
@Override
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.activity_tela1, menu);
return true;
}
}
Agora adicione eventos a essa activity.
Adicionando Eventos
De forma similar ao swing e awt (do Java), para adicionar um evento classe
necessrio implementar uma ou mais interfaces, de acordo com o evento
desejado.
Para
implementar
o
evento
clique
do
boto,
interface OnClickListener do pacote android.view.View.
utilize
Obs: Para conhecer mais sobre esta interface acesse o site da documentao
do
Android
no
link:http://developer.android.com/reference/android/view/View.OnClickListener.h
tml
No cdigo da classe digite implements e On e pressione Ctrl + espao. Para a
complementao de cdigo sero mostradas as opes disponveis:
Selecione a opo desejada que, no caso deste

interface OnClickLister do pacote android.view.View:
exemplo,
Obs: Fique atento, pois existem duas interfaces OnClickListener: uma do

pacote android.view.View e
outra
do
pacoteandroid.content.DialogInterface. Se a interface do segundo pacote
for utilizada, dar erro.
Note que a classe est apresentando um erro. Para identific-lo, clique no cone
da lmpada com o x vermelho, na frente da linha:
Observe, pela mensagem de erro, que est faltando a implementao do

mtodo onClick(). Como a documentao do Android estruturada da mesma
forma que a documentao do Java, o Eclipse j fornece possveis solues
para o erro.
O que se quer implementar o mtodo. Ento, selecione a primeira opo
sugerida pelo Eclipse (Add unimplemented methods) e o mtodo ser
criado:
public class Tela1 extends Activity implements OnClickListener {
@Override
}
@Override
return true;
}
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
}
}
Agora voc dever associar esse evento ao boto.
Associando o evento ao boto

Para associar o evento ao boto, primeiro preciso identificar o boto com o
mtodo findViewById (esse mtodo sempre ser utilizado para identificar os
widgets do projeto). O mtodo recebe como parmetro a constante referente
ao widget que se quer localizar, conforme mostra o seguinte cdigo:
Button btn = (Button) findViewById(R.id.buttonProximo);
Note que, alm de identificar o widget, est convertendo o resultado do

mtodo para o tipo Button e atribuindo a uma varivel tambm tipo Button.
Lembre-se de importar a classe Button:
import android.widget.Button;
Obs: O mtodo findViewById retorna uma View; para utilizar os eventos e

mtodo do widget corretamente preciso converter o resultado para o tipo do
widget com que se ir trabalhar.
Agora voc j tem a varivel que representa o widget para associ-lo ao
evento: o mtodo setOnClickListener, passando como parmetro a palavrachave this (que representa a classe atual):
btn.setOnClickListener(this);
Esse cdigo ser adicionado ao mtodo OnCreate da seguinte forma:

}
Falta apenas adicionar o cdigo do mtodo onClick, que ir obter o contedo

da caixa de texto (o EditText) e atribuir o resultado a uma varivel, que ser
atribuda novamente ao TextView resultado. Conforme mostra o cdigo
abaixo:
TextView tvResultado = (TextView) findViewById(R.id.textViewResposta);
EditText txtNome = (EditText) findViewById(R.id.editTextNome);
String msg = "Nome: " + txtNome.getText().toString();
tvResultado.setText(msg);
}
Tambm importe as duas classes dos widgets:

import android.widget.EditText;
import android.widget.TextView;
O cdigo da classe ficar da seguinte forma:

import android.view.View;
import android.view.View.OnClickListener;
@Override

}
@Override
return true;
}
@Override
TextView tvResultado = (TextView) findViewById(R.id.textViewResposta);
String msg = "Nome: " + txtNome.getText().toString();
tvResultado.setText(msg);
}
Salve o arquivo e execute o projeto:
Digite seu nome e clique no boto OK para exibir o contedo da caixa de texto
no TextView.
Criando uma nova tela
Para criar uma nova activity (tela) no projeto siga a seguinte ordem:
1 Criar os recursos de texto do activity no arquivo strings.xml.

2 Criar na pasta res/layout um novo arquivo de layout.
3 Criar uma nova classe Java estendendo a classe Activity.
4 Chamar a nova Activity.
Fora a primeira opo (caso voc j possua os recursos de texto), as demais
devem ser sempre executadas na ordem acima; caso contrrio, o projeto no
reconhecer a nova Activity.
Siga estas etapas:
1 Criando os recursos
Adicione no arquivo strings.xml os
indicado no cdigo a seguir:
recursos titulo e ensino,
conforme
<resources>
<string name="ensino">Treinaweb Cursos</string>
<string name="titulo">Informaes do curso</string>
</resources>
2 Criando um novo arquivo de layout

No Package explorer, clique com o boto direito do mouse sobre a
pasta res/layout e selecione a opo New > Android XML File, conforme
mostra a seguinte imagem:
A janela New Android XML File ser exibida:
Em File, digite activity_tela2. Nos demais campos, mantenha as opes

padro, conforme mostra a imagem a seguir:
Clique em Finish e o arquivo activity_tela2.xml ser apresentado no editor:
Adicione dois widgets TextViews tela:
Se os widgets forem organizados horizontalmente, possvel modificar essa

orientao clicando no cone:
Que se encontra no topo da tela (o segundo cone da esquerda para a direita):
Adicione
mais
um TextView e
associe-os
recursos: titulo, curso e ensino, conforme a imagem abaixo:
com
os
Para finalizar essa etapa, salve seu arquivo (Ctrl+S).
3 Criando a classe Java

Como explicado anteriormente, para criar uma tela no Android necessrio ter
uma classe Java que estenda a classe Activity. Dessa forma criada uma
activity, isto , uma tela para o Android.
Para adicionar uma nova classe Java, clique com o boto direito do mouse
sobre o pacote br.com.treinaweb.parte1, da pasta src, e selecione a
opo New > Class, conforme mostra a imagem a seguir:
A caixa de dilogo New Java Class ser exibida:
Para definir que a classe ir estender a

boto Browse, na opo Superclass, para
Selection seja exibida:
Em Choose a type digite Activity para

seguintes opes:
classe Activity, clique no

que a janela Superclass
exibir,
em Matching items, as
Selecione a primeira opo (Activity) e clique em OK:
Em Name preencha Tela2, conforme mostra a imagem acima, e clique

em Finish para criar a classe:
Agora adicione o mtodo onCreate, conforme indicado no cdigo abaixo:

public void onCreate(Bundle savedInstanceState){
}
}
Observe que o novo layout est sendo referenciado:
4 Exibindo a nova tela

Para exibir a nova tela, primeiro
arquivo AndroidManifest.xml:
preciso
mapear
activity
Mude para o cdigo-fonte (selecione a aba AndroidManifest.xml):
no
Aps a tag </activity> adicione a activity, conforme o cdigo abaixo:

<activity
android:name="br.com.treinaweb.parte1.Tela2"
android:label="@string/app_name">
</activity>
Observe,
no
cdigo
acima,
que
no
foi
necessrio
declarar
uma Intent (inteno) para a Tela2. No primeiro activity a Intent foi
adicionada automaticamente, sendo necessria para especificar a classe que
ser executada ao iniciar a aplicao (semelhante ao mtodo main do Java).
O arquivo AndroidManifest.xml ficar da seguinte forma:
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="br.com.treinaweb.parte1"
android:versionCode="1"
android:versionName="1.0" >
<uses-sdk
android:minSdkVersion="9"
android:targetSdkVersion="17" />
<application
android:allowBackup="true"
android:icon="@drawable/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme" >
<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>
<activity
</activity>
</application>
</manifest>
Obs: Para alterar o activity inicial da aplicao basta modificar a linha abaixo,
inserindo o nome do novo activity:
<activity
Ou adicionar no intent filter do activity a action MAIN:

Lembrando que apenas uma activity pode ter a action MAIN em uma aplicao.
Executando o projeto para visualizar a

nova tela
Execute o projeto:
Clique no boto para a segunda tela ser apresentada:
Voltando para a tela anterior

Para retornar tela anterior, necessrio adicionar um boto na segunda tela
(activity_tela2.xml) e program-lo para retornar, conforme mostra a imagem
a seguir:
O cdigo-fonte da tela ser o seguinte:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical" >
<TextView
android:text="@string/titulo" />
<TextView
android:text="@string/curso" />
<TextView
android:text="@string/ensino" />
<Button
android:id="@+id/buttonVoltar"
android:text="@string/botao_voltar" />
</LinearLayout>
J no activity Tela2, implemente a interface OnClickListener e o

mtodo OnClick, atribuindo-o ao boto recm-aplicado no arquivo de
interface, conforme indicado no cdigo abaixo:
Button btnVoltar = (Button) findViewById(R.id.buttonVoltar);
btnVoltar.setOnClickListener(this);
}
@Override
public void onClick(View arg0) {
finish();
}
Note que foi usado apenas o mtodo finish() para encerrar a activity atual (no
caso, Tela2) e voltar para a activity anterior (Tela1).
Executando o projeto
Execute a aplicao e clique no boto OK para exibir a segunda activity:
Clique no boto Voltar para retornar primeira activity:
Para entender os eventos que ocorrem com cada activity (tela) necessrio
conhecer o ciclo de vida e os eventos das mesmas.
Ciclo de vida das Activities

As activities so armazenadas na memria como se fossem uma pilha (stack)
de telas, uma em cima da outra, ficando visvel para o usurio a que est por
cima de todas.
Quando uma nova tela apresentada colocada no topo da pilha, ficando a
anterior logo abaixo dela.
Cada activity possui um ciclo de vida especfico:
Onde:
onCreate(): Mtodo chamado quando a atividade criada. Nele so

criadas as views e obtidos os dados que iro carregar as listas da tela.
onStart(): Mtodo chamado quando a atividade torna-se visvel para o
usurio.
onResume(): Esse mtodo ocorre quando a atividade est no topo da
pilha e o usurio j pode interagir com a tela.
onPause(): Chamado quando a atividade est comeando a ser
substituda ou a aplicao est comeando a se encerrar. Geralmente
utilizado para gravar as informaes que ainda no foram salvas.
onRestart(): Esse mtodo ocorre quando o atividade pausada e

chamada novamente.
onStop(): Esse mtodo ocorre quando a atividade no estiver sendo
executada e saiu do topo da pilha de atividades.
onDestroy(): Chamado quando a atividade finalizada; pode ser por
cdigo ou quando o sistema precisa liberar recursos.
Entendendo o ciclo de vida

Assim que uma atividade iniciada colocada no topo da pilha de atividades e
se torna uma atividade em execuo. Caso exista alguma atividade anterior,
ela ficar em uma posio logo abaixo na pilha e s passar para o estado de
execuo quando a atividade acima for finalizada.
So quatro estados em que uma atividade pode se encontrar:
Executando: a atividade que est ativa na tela do dispositivo.

Parada: uma atividade que perdeu o foco para outra, mas que mantm
todas as informaes de estado, porm sem interagir com o usurio. Pode ser
finalizada se o sistema operacional necessitar de memria (recursos).
Interrompida: Caso da atividade que no est sendo utilizada, mas que
mantm as suas informaes de estado, porm finalizada para a liberao de
memria, perdendo suas informaes.
Finalizada: Quando a atividade finalizada pelo sistema operacional ou
por uma implementao do desenvolvedor.
Tanto no status de Parada como no de Interrompida, o sistema pode finalizar
a atividade caso os recursos estejam baixos, sem que sejam chamados os
mtodos onDestroy ou onStop, como demonstra o diagrama acima.
Basicamente podem ocorrer trs ciclos com uma atividade:
Ciclo completo: inicia-se no mtodo onCreate() e a atividade realiza

toda a configurao, passando de um estado para o outro e terminando no
mtodo onDestroy(), quando todos os recursos utilizados pela atividade so
liberados.
Ciclo de vida visvel: inicia-se no mtodo onStart() e termina no
mtodo onStop(). o ciclo onde a atividade est disponvel e visvel para o
usurio, mesmo que ele no esteja interagindo com a tela. Quando o usurio
no visualizar mais a atividade, o mtodo onStop() chamado; ou ento, para
tornar a atividade visvel, chama-se o mtodo onStart().
Primeiro ciclo da atividade: ocorre entre os
mtodos onResume() e onPause(). Este o perodo em que a atividade est
visvel e interagindo com o usurio, no topo da pilha de atividades. O cdigo
utilizado nesse perodo no pode ser pesado, pela iminente possibilidade de
troca dos estados onPause() e onResume().
A movimentao de uma atividade para outra ocorre atravs da Intent,

requisies disparadas pelas atividades para descrever o que pode ser feito em
caso de acionamento.
Layouts
Layouts so classes que formam a infraestrutura da tela (view), facilitando a
distribuio dos vrios widgets nela.
No exemplo, foram usados dois tipos de layout para construir as telas. O
primeiro o RelativeLayout do arquivo activity_tela1.xml:
<TextView
<EditText
android:ems="10"
<requestFocus />
</EditText>
<Button
<TextView
</RelativeLayout>
Note o incio do arquivo:

nele que se informa o tipo de layout do arquivo. Esse layout ser explicado
frente.
O segundo o LinearLayout de activity_tela2.xml:
<TextView
<TextView
<TextView
<TextView
android:id="@+id/textViewAluno"
<Button
</LinearLayout>
Note que foi usado o LinearLayout:

O LinearLayout posiciona os objetos na sequncia, um aps o outro, na

horizontal ou vertical, dependendo do atributo orientation. No cdigo acima
eles esto organizados na posio vertical.
O Android disponibiliza uma srie de opes de layouts, sendo os principais:
LinearLayout
TableLayout
RelativeLayout
AbsoluteLayout
FrameLayout
A primeira opo a mais simples, usada na activity_tela2.xml, como
mostrado no exemplo acima. Os demais sero demonstrados a seguir.
Layouts
Layouts so classes que formam a infraestrutura da tela (view), facilitando a
distribuio dos vrios widgets nela.
No exemplo, foram usados dois tipos de layout para construir as telas. O
primeiro o RelativeLayout do arquivo activity_tela1.xml:
<TextView
<EditText
android:ems="10"
<requestFocus />
</EditText>
<Button
<TextView
</RelativeLayout>
Note o incio do arquivo:

nele que se informa o tipo de layout do arquivo. Esse layout ser explicado
frente.
O segundo o LinearLayout de activity_tela2.xml:
<TextView
<TextView
<TextView
<TextView
android:id="@+id/textViewAluno"
<Button
</LinearLayout>
Note que foi usado o LinearLayout:
O LinearLayout posiciona os objetos na sequncia, um aps o outro, na

horizontal ou vertical, dependendo do atributo orientation. No cdigo acima
eles esto organizados na posio vertical.
O Android disponibiliza uma srie de opes de layouts, sendo os principais:
LinearLayout
TableLayout
RelativeLayout
AbsoluteLayout
FrameLayout
A primeira opo a mais simples, usada na activity_tela2.xml, como
mostrado no exemplo acima. Os demais sero demonstrados a seguir.
TableLayout
O TableLayout permite trabalhar com linhas como se fosse uma tabela do
HTML (mas bem mais limitada) e as colunas so criadas automaticamente
quando algum widget adicionado.
Faa este exemplo: Crie um novo arquivo de layout, activity_tela3.xml.
Primeiro selecione o layout TableLayout, conforme mostra a imagem a seguir:
Note a listagem em Root Element; nela definido o tipo do elemento raiz do

layout que, no caso deste exemplo, TableLayout. Clique emFinish para criar
o arquivo:
Mude para o modo grfico e clique na aba Graphical Layout:
Exemplo de TableLayout
Para adicionar uma linha ao layout, selecione o objeto TableRow, presente na
categoria Layouts da Palette:
Adicione dois TableRow ao layout: no primeiro insira um TextView e

um EditText (Person Name); no segundo insira um boto, conforme indicado
no cdigo-fonte abaixo:
<TableLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_height="match_parent" >
<TableRow
android:id="@+id/tableRow1"
android:layout_height="wrap_content" >
<TextView
android:id="@+id/textViewNome"
android:layout_width="60dp"
android:layout_height="40dp"
android:text="@string/nome" />
<EditText
android:ems="10"
android:inputType="textPersonName" >
<requestFocus />
</EditText>
</TableRow>
<TableRow
android:id="@+id/tableRow2"
android:gravity="center|" >
<Button
android:id="@+id/buttonOk"
</TableRow>
</TableLayout>
Note que, para alinhamento dos objetos dentro da coluna, foi usado o atributo
gravity que possui diversas opes que aparecem ao se utilizar as teclas CTRL
+ Espao, forando a complementao do cdigo:
Unidades de medida utilizadas no

Android
Observe tambm que os widgets esto sendo dimensionados, usando a
unidade dp. O Android suporta as seguintes unidades de medida:
px (pixel) ou pontos na tela.

mm (millimeters) ou milmetros.
pt (points) um ponto ou 1/72 de uma polegada.
dp (density-independent pixels) uma unidade abstrata baseada na
densidade da tela. (Em uma tela com 160 pontos por polegada, 1dp = 1px).
dip: Sinnimo de dp (utilize dp no lugar de dip)
sp (scale-independent pixels) similar dp mas leva em considerao a
fonte do texto.
Alm do fill_parent (que ocupa todo o espao onde o objeto est contido) e
da wrap_content (onde o objeto se ajusta ao seu contedo).
Para usar uma unidade de medida basta informar seu valor seguido da
unidade. A recomendao utilizar as meditas relativas, como spe dp, por
facilitar a quem trabalha com mltiplas resolues.
Criando a Activity
Voltando ao exemplo de TableLayout, crie uma classe Java que ir estender a
classe Activity do Android, conforme mostra o cdigo a seguir:
@Override
}
}
Para definir esta activity como tela inicial da aplicao, voc dever modificar o
arquivo Android.Manifest. Nele, com o intent-filter da activity Tela1, crie
uma tag <activity> para a nova activity Tela3. Faa da seguinte forma:
<activity
<intent-filter>
</intent-filter>
</activity>
Remova
o intent-filter da
activity Tela1 para
no
arquivo Android.Manifest ficar da seguinte forma:
gerar
erro.
<uses-sdk
<application
<activity
</activity>
<activity
</activity>
<activity
<intent-filter>
</intent-filter>
</activity>
</application>
</manifest>
Ao executar a aplicao, o layout activity_tela3.xml ser apresentado:
Resoluo do Emulador
Para visualizar como os widgets e a aplicao se comportam em outras
resolues, basta alterar as configuraes do prprio emulador.
Abra o Android Virtual Dervice Manager pelo menu iniciar,
opo Windows > Android Virtual Dervice Manager do Eclipse:
O Android Virtual Dervice Manager ser aberto:
ou
na
Selecione o seu emulador e clique no boto Edit para ser exibida a seguinte
caixa de dilogo:
Na opo Device voc pode escolher outra opo de Device, que possua
outra resoluo:
Clique no boto Ok para salvar as alteraes.

Feche o emulador, caso ele esteja aberto, e execute novamente o projeto para
visualiz-lo em nova resoluo:
Teste as demais opes disponveis.
RelativeLayout
Esse tipo de layout foi mostrado no primeiro exemplo do curso. Ele baseado
em posies relativas de um widget em relao a outro pr-existente. Para
esse tipo de layout o atributo ID do widget obrigatrio.
Crie um novo arquivo de layout RelativeLayout, contendo os mesmos widgets
do exemplo anterior: um TextView, um EditText (Person Name) e
um Button, conforme indicado no cdigo abaixo:
<Button
android:layout_below="@+id/textViewNome"
<TextView
android:layout_alignBaseline="@+id/editTextNome"
android:layout_alignBottom="@+id/editTextNome"
<EditText
android:layout_alignParentRight="true"
android:layout_marginRight="15dp"
android:ems="10"
android:inputType="textPersonName" />
</RelativeLayout>
Observe a linha:
Ela indica que o widget deve se posicionar esquerda do widget cujo ID

editTextNome.
Voc
pode
conhecer
todos
os
parmetros
na
documentao
online:http://developer.android.com/reference/android/widget/RelativeLayout.La
youtParams.html
Para este layout no necessrio criar nova Activity, bastando alterar a
activity Tela3:
@Override
setContentView(R.layout.relative_activity_tela3);
}
}
Note a linha:
setContentView(R.layout.relative_activity_tela3);
Nela definido que a activity ir exibir o layout recm-criado. Lembrando que

se voc criou um arquivo de layout com outro nome, ele deve ser informado
nessa linha:
Ao executar a aplicao ele ser exibido:
FrameLayout
O FrameLayout um espao reservado na tela que voc pode utilizar para
exibir outro tipo de contedo, como no exemplo abaixo:
<Button
android:layout_below="@+id/textViewNome"
<TextView
android:layout_alignBaseline="@+id/editTextNome"
android:layout_alignBottom="@+id/editTextNome"
<EditText
android:layout_alignParentRight="true"
android:layout_marginRight="15dp"
android:ems="10"
android:inputType="textPersonName" />
<FrameLayout
android:layout_below="@+id/buttonOk"
android:layout_toRightOf="@+id/buttonOk" >
<ImageView
android:id="@+id/imageView1"
android:src="@drawable/ic_launcher"
android:contentDescription="@string/imagem" />
</FrameLayout>
</RelativeLayout>
No cdigo acima, o exemplo do RelativeLayout foi modificado, pois foi

includo um FrameLayout com uma imagem. Ao executar o projeto, a tela
ser exibida com a imagem:
Vrios widgets podem ser adicionados em um FrameLayout, mas cada um

ficar sobre o outro como em uma pilha.
ScrollView
O ScrollView um tipo especial de layout que permite aos usurios arrastar a
tela para visualizar todos os pontos do layout. O ScrollViewpode conter
apenas um View ou ViewGroup, que normalmente um LinearLayout.
Faa este exemplo: crie um novo arquivo de layout, baseado no
template ScrollView,
e
adicione
um LinearLayout e
alguns Button,
conforme mostra o cdigo abaixo:
<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
<LinearLayout
<Button
android:id="@+id/button1"
<Button
<Button
</LinearLayout>
</ScrollView>
Modifique a activity Tela3 para exibir este layout e execute o projeto:
Observe que agora existe uma barra de rolagem do lado direito da tela,
permitindo aos usurios arrastar a tela para visualizar os widgets localizados
na parte inferior.
Obs: No recomendvel utilizar o ListView (explicado frente) com

o ScrollView.
Usando Widgets de Seleo

Em alguns momentos necessrio restringir o tipo de dado que o usurio pode
digitar, bem como definir as opes que ele possa ter, e apenas com
o EditText no se tem muitas opes.
Nesses casos voc deve utilizar os widgets de seleo (explicados neste tpico)
como ListView, Radio e CheckBox.
ListView
Para exibir listas no Android utiliza-se o widget ListView. Para utiliz-lo, basta
adicionar
um ListView em
um
arquivo
de
layout
e
utilizar
o
mtodo setAdapter para carregar os itens da lista, sendo que os itens podem
ser criados em um arquivo de recursos ou via cdigo.
Faa este exemplo: crie um novo arquivo de layout e
dois TextViews e um ListView, conforme mostra o cdigo abaixo:
<TextView
android:id="@+id/textViewRotulo"
android:text="@string/rotolo" />
<ListView
android:id="@+id/listViewCursos"
android:layout_alignLeft="@+id/textViewRotulo"
android:layout_below="@+id/textViewRotulo" >
</ListView>
<TextView
android:layout_alignLeft="@+id/listViewCursos"
android:layout_alignParentBottom="true"
adicione
</RelativeLayout>
Se voc mudar para o modo de designer notar que o ListView ocupa toda a
tela:
Isso acontece porque ele possui apenas informaes de exemplo para dar
noo de como a tela ser apresentada no layout.
Exemplo de ListView
A informao pode ser carregada usando os dados do arquivo de recursos.
Nesse caso, adicione o arquivo de recursos string-array e nele adicione
alguns itens, conforme o recurso abaixo:
<resources>
<string name="ensino">Treinaweb Cursos</string>
<string name="titulo">Informaes do curso</string>
<string name="botao_voltar">Voltar</string>
<string name="nome">Nome:</string>
<string name="imagem">cone aplicao</string>
<string name="rotolo">Selecione uma opo:</string>
<string-array name="cursos">
<item>Curso Android bsico</item>
<item>Curso Java bsico</item>
<item>Curso C# bsico</item>
<item>Curso VB.NET bsico</item>
</string-array>
</resources>
Para carregar o ListView preciso modificar a activity Tela3, adicionando o

cdigo abaixo:
import android.widget.ArrayAdapter;
import android.widget.ListView;
@Override
String[] cursos = getResources().getStringArray(R.array.cursos);
ArrayAdapter<String> aAdapter = new ArrayAdapter<String>(this, android.R.layout.si
mple_gallery_item, cursos);
ListView list = (ListView) findViewById(R.id.listViewCursos);
list.setAdapter(aAdapter);
}
}
Observe que o mtodo setContentView foi modificado para carregar o

arquivo de layout:
Depois, os dados do arquivo de recurso foram inseridos:

Logo em seguida a classe ArrayAdapter foi utilizada para carregar o Array,

em determinado contexto e layout:
ArrayAdapter<String> aAdapter = new ArrayAdapter<String>(this, android.R.layout.simpl
e_gallery_item, cursos);
Note que a primeira instruo this, que referencia a prpria classe; o

segundo parmetro o layout do item. H vrias opes de layout:
Depois experimente as outras opes de layout dos itens.

O ltimo parmetro do ArrayAdapter o array.
Aps o ArrayAdapter voc
o ListView:
deve
criar
uma
varivel
que
representa
Para
finalizar,
carregue
mtodo setAdapter:
o ArrayAdapter ao
Salve a activity e execute a aplicao:
ListView,
atrves
do
Agora, para carregar as informaes via cdigo, basta criar um array para ser
utilizado no ArrayAdapter:
@Override
//String[] cursos = getResources().getStringArray(R.array.cursos);
String[] cursos = {"Android Bsico", "Java Bsico", "C# Bsico"};
}
}
Note que foi comentada apenas a linha que carrega os dados do arquivo de
recurso:
E foi criado um novo array:

Execute a aplicao:
Identificando o item selecionado

Para identificar o item selecionado, basta implementar na activity
interface onItemClickListener e o mtodo onItemClick, e associar
evento ItemClick ao widget ListView, conforme o cdigo abaixo:
a
o
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ListView;
public class Tela3 extends Activity implements OnItemClickListener {
@Override
list.setOnItemClickListener(this);
}
@Override
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
TextView resposta = (TextView) findViewById(R.id.textViewResposta);
String curso = ((TextView) view).getText().toString();
resposta.setText("Resposta: " + curso);
}
}
Note que a interface foi importada:

import android.widget.AdapterView.OnItemClickListener;
Dentro do evento onCreate foi associado o ListView ao evento onItemClick:

No evento onItemClick foi declarado o TextView, sendo pego o valor do item

clicado:
String curso = ((TextView) view).getText().toString();
Repare, no cdigo acima, que o view (parmetro do mtodo) foi convertido

para um TextView; este view o item selecionado do ListView.
Para finalizar, foi carregada a informao do TextView:
resposta.setText("Resposta: " + curso);
Execute o projeto e clique em um item:
CheckBox
O CheckBox um widget que permite ao usurio selecionar quantas opes
desejar. Faa este exemplo, crie o arquivo de layout abaixo:
<TextView
<CheckBox
android:id="@+id/checkBoxAndroidBasico"
android:layout_below="@+id/textViewRotulo"
android:text="@string/android_basico" />
<CheckBox
android:id="@+id/checkBoxJavaBasico"
android:layout_below="@+id/checkBoxAndroidBasico"
android:text="@string/java_basico" />
<CheckBox
android:id="@+id/checkBoxCSharpBasico"
android:layout_below="@+id/checkBoxJavaBasico"
android:text="@string/csharp_basico" />
<Button
android:layout_below="@+id/checkBoxCSharpBasico"
<TextView
</RelativeLayout>
Note que, diferente do ListView, com o CheckBox preciso adicionar quantos

widgets forem necessrios para apresentar as opes disponveis.
Para exibir esse arquivo de layout voc deve criar uma nova activity,
denominada Tela5.java. Para verificar os CheckBoxs selecionados preciso
implementar
a
evento onClick.
interface onClickListener e
associar
boto
ao
Dentro do mtodo onClick possvel verificar os CheckBoxs selecionados

atravs da propriedade isChecked. Se ela for true, ela est selecionada; se
for false, no. Veja o cdigo da activity abaixo:
import android.widget.CheckBox;
Button btnOk = (Button) findViewById(R.id.buttonOk);
btnOk.setOnClickListener(this);
}
@Override
CheckBox chkAndroid = (CheckBox) findViewById(R.id.checkBoxAndroidBasico);
CheckBox chkJava = (CheckBox) findViewById(R.id.checkBoxJavaBasico);
CheckBox chkCSharp = (CheckBox) findViewById(R.id.checkBoxCSharpBasico);
String msg = "Curso(s) selecionado(s): ";
if(chkAndroid.isChecked())
msg += chkAndroid.getText().toString() + " ";
if(chkJava.isChecked())
msg += chkJava.getText().toString() + " ";
if(chkCSharp.isChecked())
msg += chkCSharp.getText().toString() + " ";
resposta.setText(msg);
}
}
Defina esta Activity como a Activity inicial do projeto:

<activity
<intent-filter>
</intent-filter>
</activity>
Execute o projeto, selecione os cursos e clique no boto:
Tambm possvel implementar o evento click em cada um dos CheckBoxs.

Nesse caso preciso implementar o mtodo onCkick direto no parmetro do
mtodo setOnClickListener, conforme mostra o cdigo abaixo:
final CheckBox chkAndroid = (CheckBox) findViewById(R.id.checkBoxAndroidBasico);
chkAndroid.setOnClickListener(new OnClickListener(){
@Override
public void onClick(View view) {
if(((CheckBox) view).isChecked())
resposta.setText("Curso: " + ((CheckBox) view).getText() + " selecionado!");
else
resposta.setText("Curso: " + ((CheckBox) view).getText() + " no est selecionado!");
}
});
}
Esse cdigo:
chkAndroid.setOnClickListener(new OnClickListener(){
uma classe annima do Java.
Execute o projeto e clique no CheckBox:
RadioButton
O RadioButton, assim com o CheckBox, um widget que apresenta opes.
Mas permite ao usurio selecionar apenas uma opo dentro do grupo.
Por exemplo, crie um arquivo de layout, conforme o cdigo abaixo:
<TextView
<RadioGroup android:id="@+id/rdGroupCursos"
android:layout_below="@+id/textViewRotulo">
<RadioButton
android:id="@+id/radioButtonAndroidBasico"
android:text="@string/android_basico" />
<RadioButton
android:id="@+id/radioButtonJavaBasico"
android:text="@string/java_basico" />
<RadioButton
android:id="@+id/radioButtonCSharpBasico"
android:text="@string/csharp_basico" />
</RadioGroup>
<Button
android:layout_below="@+id/rdGroupCursos"
<TextView
</RelativeLayout>
Observe que, alm dos RadioButtons, foi adicionado um RadioGroup de

forma que os botes sejam parte de um grupo. Assim, permitido que apenas
um boto possa ser marcado no grupo.
Igualmente aos CheckBoxs, para exibir esse arquivo preciso criar uma nova
activity, denominada Tela6.java. Para verificar oRadioButton selecionado
deve-se
implementar
o
evento onClick,
e
com
a
propriedade isChecked verifica-se qual widget est selecionada, conforme o
cdigo abaixo:
import android.widget.RadioButton;
}
@Override
RadioButton rbAndroid = (RadioButton) findViewById(R.id.radioButtonAndroidBasico);
RadioButton rbJava = (RadioButton) findViewById(R.id.radioButtonJavaBasico);
RadioButton rbCSharp = (RadioButton) findViewById(R.id.radioButtonCSharpBasico);
String msg = "Curso selecionado: ";
if(rbAndroid.isChecked())
msg += rbAndroid.getText().toString() + " ";
if(rbJava.isChecked())
msg += rbJava.getText().toString() + " ";
if(rbCSharp.isChecked())
msg += rbCSharp.getText().toString() + " ";
}
}
Altere esta Activity para a Activity inicial do projeto e execute:
Tambm possvel implementar o evento onClick em cada um dos Button,

como no CheckBox, conforme o cdigo abaixo:
final RadioButton rbAndroid = (RadioButton) findViewById(R.id.radioButtonAndroidBasico);
rbAndroid.setOnClickListener(new OnClickListener(){
@Override

if(((RadioButton) view).isChecked())
resposta.setText("Curso: " + ((RadioButton) view).getText() + " selecionado!");
else
resposta.setText("Curso: " + ((RadioButton) view).getText() + " no est selecionado!");
}
});
final RadioButton rbJava = (RadioButton) findViewById(R.id.radioButtonJavaBasico);
rbJava.setOnClickListener(new OnClickListener(){
@Override
else
}
});
final RadioButton rbCSharp = (RadioButton) findViewById(R.id.radioButtonCSharpBasico);
rbCSharp.setOnClickListener(new OnClickListener(){
@Override
else
}
});
Execute o projeto e clique em algum boto:
Spinner
Spinner um widget que permite ao usurio selecionar apenas uma opo em
uma caixa suspensa como um ComboBox.
Faa este exemplo: Crie o arquivo de layout, conforme mostra o cdigo abaixo:
<TextView
<Spinner android:id="@+id/spinnerCursos"
android:layout_below="@+id/textViewRotulo">
</Spinner>
<Button
android:layout_below="@+id/spinnerCursos"
<TextView
</RelativeLayout>
O Spinner semelhante ao ListView para carregar os itens, ou seja: eles

podem ser carregados de um Array ou de um arquivo de recursos da mesma
forma que o ListView.
Faa este exemplo: Crie uma nova activity denominada Tela7.java, conforme
mostra o cdigo abaixo:
import android.widget.Spinner;
private Spinner spnCursos;
spnCursos = (Spinner) findViewById(R.id.spinnerCursos);
spnCursos.setAdapter(aAdapter);
}
@Override
String msg = " Curso selecionado: ";
msg += ((TextView) spnCursos.getSelectedView()).getText().toString();
}
}
Note que o Spinner foi declarado fora do mtodo onCreate para poder ser
visvel dentro do mtodo onClick. Tambm observe que para pegar a
informao
do
item
selecionado,
foi
utilizada
a
propriedade getSelectedView(), convertida para TextView para obter o texto
da opo.
Coloque essa activity como inicial e execute o projeto:
Selecione uma opo do combo:
Clique no boto OK:
Tipos de Recursos
Todos os recursos do projeto ficam organizados dentro da pasta res. Eles so
mapeados para binrio e acessados atravs de classe de recursos (a
classe R da pasta gen). Para evitar qualquer problema de compilao, o
Android define onde cada tipo de recurso deve ser includo, como os layouts na
pasta res/layout e
as strings na
pasta res/values,
dentro
de
um
arquivo strings.xml.
Agora sero explicados mais alguns recursos que podem ser adicionados ao
projeto.
Recurso Color
Existem vrias formas de aplicar e modificar as cores do projeto. A mais
simples criar um arquivo xml dentro da pasta res/values, contendo o nome
da cor e o valor em RGB.
Esse arquivo deve, obrigatoriamente, ser denominado colors.xml.
Para criar o arquivo, clique com o boto direito do mouse sobre a
pasta res/values e selecione a opo New > Android XML File. A caixa de
dilogo abaixo ser exibida:
Em File, preencha colors.xml e clique em Finish para criar o arquivo:
Adicionando um recurso de cor
Para adicionar um recurso de cor, clique no boto Add... A seguinte caixa de

dilogo ser exibida:
Selecione Color e clique em OK:
Em Name preencha o nome da cor; em Value, o valor da cor em hexadecimal

seguindo um dos padres abaixo:
#RGB
#ARGB
#RRGGBB
#AARRGGBB
Neste exemplo digite azul em Name e #0000FF em Value, conforme mostra
a imagem abaixo:
Mude para o cdigo-fonte (clique na aba colors.xml):

<resources>
<color name="azul">#0000FF</color>
</resources>
Note que a cor foi criada em uma tag color onde o atributo name possui o
nome da cor; entre as tags fica localizado o valor hexadecimal.
Preencha algumas cores no arquivo pelo mtodo visual ou diretamente no
cdigo-fonte. Em caso de dvida sobre os cdigos das cores, voc pode utilizar
a tabela: http://www.treinaweb.com.br/treinamentos/arquivos/cores.html
O arquivo de exemplo que ser utilizado contm as seguintes cores:
<resources>
<color name="azul">#0000FF</color>
<color name="branco">#FFFFFF</color>
<color name="cinza">#CCCCCC</color>
<color name="prento">#000000</color>
<color name="laranja">#FF9900</color>
<color name="vermelho">#FF0000</color>
<color name="rosa">#FF00CC</color>
<color name="verde">#00FF00</color>
<color name="amarelo">#FFFF00</color>
</resources>
As cores includas nesse arquivo podem ser aplicadas a qualquer arquivo de

layout. Faa este exemplo: Abra o cdigo-fonte do arquivoactivity_tela1.xml.
Para alterar a cor do texto de widget utilize o atributo textColor, da seguinte

forma:
android:textColor="@color/vermelho"
Para alterar a cor de fundo utilize o atributo background:

android:background="@color/prento"
Modifique as cores de alguns widgets, de acordo com o seguinte cdigo:

tools:context=".Tela1"
android:background="@color/prento" >
<TextView
android:text="@string/msg"
android:textColor="@color/vermelho" />
<EditText
android:ems="10"
android:text="@string/texto_nome"
android:textColor="@color/vermelho" >
<requestFocus />
</EditText>
<Button
android:text="@string/botao_ok"
<TextView
android:text="@string/resposta"
</RelativeLayout>
O layout ficar da seguinte forma:
Recursos Grficos
Os recursos grficos so includos na pasta res/drawable e podem ser
imagens (png, jpg ou gif) ou um xml que define ou faz referncia a uma
imagem. Neste curso bsico sero demonstradas apenas as imagens.
Note que dentro da pasta res existem mais quatro pastas drawable:
Nelas devem ser colocadas as imagens, de acordo com cada tipo de resoluo
que os dispositivos possuem, sendo que so de extra-alta densidade (xhdpi),
alta densidade (hdpi), mdia densidade (mdpi) e baixa densidade (ldpi).
Para saber a resoluo correta de cada densidade, consulte a tabela abaixo:
Obs: Como ser explicado frente, o arquivo deve possuir o mesmo nome nas
trs pastas ou ocorrer um erro de compilao.
Para ajudar a organizar os cones da aplicao, a documentao do Android
sugere a seguinte nomenclatura para a nomeao dos cones:
Na hora em que eles forem criados, organize-os de acordo com a resoluo:
Dessa forma, voc pode determinar facilmente onde cada arquivo ser
adicionado ao projeto. Para efeito de comparao, os citados acima ficaram
organizados da seguinte forma na aplicao:
cones de exemplo
No momento voc no precisa se preocupar com a criao de cones porque
todos os que sero utilizados nos prximos exemplos so disponibilizados pelo
SDK.
V no caminho ...\sdk\platforms\android-17\data\res:
Obs: Esse caminho pertence verso android-17. Se voc estiver usando

outra verso, o nome dessa pasta ser diferente.
Note que est disponvel grande quantidade de cones nas diversas resolues.
Antes de copiar os cones que sero usados nos prximos exemplos, crie dento
da pasta C:\Curso\Android as pastas da imagem abaixo:
Depois copie os cones abaixo das pastas do SDK (sdk\platforms\android17\data\res ) para as pastas cones\ic_menu* de acordo com a resoluo:
Para adicionar as imagens ao projeto, basta arrast-las de cada pasta para

dentro das respectivas pastas de recursos do seu projeto no Eclipse:
Selecione a opo Copy Files e clique no boto OK.

A pasta de recursos ficar da seguinte forma:
Repita
a
operao
para
as
pastas drawable-hdpi, drawableldpi e drawable-mdpi de forma a ter as imagens para as 4 resolues.
Para criar o menu (explicado no prximo tpico), alm dos cones necessrio
criar os textos. Desta forma, adicione os recursos abaixo no
arquivo strings.xml:
<string name="menu_archive">Arquivo</string>
<string name="menu_attchment">Adicionar um arquivo</string>
<string name="menu_delete">Excluir</string>
<string name="menu_edit">Editar</string>
<string name="menu_home">Home</string>
<string name="menu_more">Mais</string>
<string name="menu_save">Salvar</string>
<string name="menu_search">Pesquisar</string>
Note que os recursos de texto foram nomeados com um nome semelhante ao

cone. Dessa forma, os recursos ficam padronizados e facilitam a programao.
Recursos de Menu
No Android o contedo dos menus fica organizado em um arquivo xml dentro
da pasta res/menu.
Para criar o arquivo de recursos do menu, clique com o boto direito do mouse
sobre a pasta menu e selecione a opo New > Android XML File:
Voc no precisa fazer isso no momento, pois j foi criado um arquivo de menu
para a aplicao:
Abra o arquivo:
Para adicionar um elemento ao menu clique no boto Add...:
Voc
tambm
pode
adicionar
um item ou
um group.
O
elemento item representa cada item de menu e o elemento group, que
opcional e invisvel, permite agrupar itens de menu para a configurao de
propriedades comuns (como estado, visibilidade). Selecione o elementoitem e
clique em OK.
Note que h vrias opes de atributos para um item do menu. Altere apenas
os atributos id, title e icon, conforme a imagem abaixo:
Salve o arquivo. Antes de prosseguir, remova o primerio item (menu_settings).

Basta selecion-lo e clicar em Remove...:
Clique em Yes para remov-lo.
Preparando o exemplo
Mude para o seguinte cdigo-fonte:
<menu xmlns:android="http://schemas.android.com/apk/res/android" >
<item android:id="@+id/menu_archive" android:title="@string/menu_archive" android:i
con="@drawable/ic_menu_archi
ve"></item>
</menu>
Os 3 atributos configurados no item do menu:

<item android:id="@+id/menu_archive"
android:title="@string/menu_archive"
android:icon="@drawable/ic_menu_archive">
Possuem a funo:
android:id: Identificar o item do menu via programao. Esse valor deve ser
nico. Utiliza-se menu_archive para ficar coerente com os recursos de texto e
imagens.
android:icon: Configurar o cone que ser apresentado no menu. Utilizase @drawable/ic_menu_archive para obter o cone a partir dos recursos de
imagem, ou seja: as imagens nas pastas drawable-*.
android:title: Configurar o texto que ser apresentado no item. Utilizase @string/menu_archive para obter o texto a partir do arquivo de recursos.
Agora adicione os demais itens no arquivo:
android:icon="@drawable/ic_menu_archive"></item>
<item android:id="@+id/menu_edit"
android:title="@string/menu_edit"
android:icon="@drawable/ic_menu_edit"></item>
<item android:id="@+id/menu_save"
android:title="@string/menu_save"
android:icon="@drawable/ic_menu_save"></item>
<item android:id="@+id/menu_home"
android:title="@string/menu_home"
android:icon="@drawable/ic_menu_home"></item>
<item android:id="@+id/menu_delete"
android:title="@string/menu_delete"
android:icon="@drawable/ic_menu_delete"></item>
<item android:id="@+id/menu_more"
android:title="@string/menu_more"
android:icon="@drawable/ic_menu_more"></item>
</menu>
Carregando o menu
Para utilizar o menu crie um novo arquivo de layout com dois TextView,
conforme indicado no cdigo abaixo:
<TextView
android:id="@+id/textViewTitulo"
<TextView
android:layout_alignLeft="@+id/textViewTitulo"
android:layout_below="@+id/textViewTitulo"
</RelativeLayout>
Crie a seguinte activity:

@Override
}
}
Para carregar o menu preciso criar o mtodo onCreateOptionsMenu, que

ser chamado no momento em que a activity for carregada. Dentro dele utilize
o mtodo inflate, da classe MenuInflater, para criar o menu, conforme o
seguinte cdigo:
@Override
}
@Override
return true;
}
}
Configure esta activity para activity inicial da aplicao:

<activity
<intent-filter>
</intent-filter>
</activity>
Em execuo
Execute a aplicao:
Para exibir o menu, clique no boto Menu do emulador:
Ele ser exibido:
Se voc clicar em alguma das opes do menu nada ir acontecer ainda

porque nenhuma ao foi configurada.
Obs: Os cones do menu s aparecem nas verso 1.X e 2.X do Android. Como a
aplicao no est sendo executada nessa verso, os cones no sero
exibidos.
Programando o menu
Quando o usurio clicar em alguma das opes do menu, o sistema ir gerar o
evento onOptionsItemSelected. Esse mtodo recebe o item selecionado do
menu como parmetro, sendo poassvel identificar o item atravs do

mtodo getItemId():
import android.view.MenuItem;
@Override
}
@Override
return true;
}
public boolean onOptionsItemSelected(MenuItem item){
TextView tvResposta = (TextView) findViewById(R.id.textViewResposta);
String msg = "";
switch(item.getItemId()){
case R.id.menu_archive:
msg = "Selecionada a opo Arquivo";
break;
case R.id.menu_edit:
msg = "Selecionada a opo Editar";
break;
case R.id.menu_save:
msg = "Selecionada a opo Salvar";
break;
case R.id.menu_home:
msg = "Selecionada a opo Home";
break;
case R.id.menu_delete:
msg = "Seleionada a opo Excluir";
break;
case R.id.menu_more:
msg = "Selecionada a opo Mais";
break;
}
tvResposta.setText(msg);
return true;
}
}
Execute a aplicao, exiba o menu e selecione uma opo:
Caixa de dilogo
Pode-se criar uma janela de dilogo para notificar o usurio, utilizando a
classe AlertDialog.Builder.
Alm de instanciar a classe AlertDialog.Builder preciso configurar o texto
da janela com o mtodo setMessage, e o ttulo com o mtodosetTitle; resta
ainda a opo de configurar um cone com o mtodo setIcon, e o boto com o
mtodo setNeutralButton. Por exemplo:
AlertDialog.Builder mBox = new AlertDialog.Builder(this);
mBox.setMessage("Selecionado a opo Arquivo");
mBox.setTitle("Arquivo");
mBox.setIcon(R.drawable.ic_menu_archive);
mBox.setNeutralButton("OK", null);
mBox.show();
break;
Ao executar a aplicao e selecionar a opo de Arquivo:
Observe que a tela de trs perdeu o foco e a janela de dilogo est aguardando
alguma interao com o usurio, que nesse caso s pode clicar no boto OK.
Ao clicar no boto nenhuma ao ser realizada, pois o evento do click do
boto ainda no foi programado.
Para configurar o clique de um boto preciso implementar a
interface onClickListener.
Assim
como
voc
implementou
no CheckBox eRadioButon, implemente o evento onClick diretamente no
parmetro do mtodo de definio do boto, conforme o cdigo abaixo:
final TextView tvResposta = (TextView) findViewById(R.id.textViewResposta);
String msg = "";
mBox.setMessage("Selecionado a opo Arquivo");
mBox.setNeutralButton("OK", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
tvResposta.setText("Boto OK Clicado");
...
}
});
mBox.show();
break;
Note que o mtodo onClick foi implementado diretamente no parmetro do

mtodo setNeutralButton:
@Override
}
});
Observe tambm que agora a varivel tvStatus final:

Execute a aplicao, exiba o menu e clique na opo Arquivo:
Clique no boto OK:
Configurando a janela de confirmao

Outra opo de janela de dilogo na classe AlertDialog.Builder exibir uma
janela de confirmao. Nesse caso o cdigo um pouco mais complexo, pois
preciso
adicionar
dois
botes:
a
opo
afirmativa,
com
o
mtodo setPositiveButton,
e
a
opo
negativa,
com
o
mtodo setNegativeButton. Por exemplo:
private void excluirCadastro(){
mBox.setMessage("Deseja excluir o cadastro selecionado");
mBox.setTitle("Excluir cadastro");
mBox.setIcon(R.drawable.ic_menu_delete);
mBox.setPositiveButton("Sim", new DialogInterface.OnClickListener() {
@Override
tvResposta.setText("Boto Sim clicado");
}
});
mBox.setNegativeButton("No", new DialogInterface.OnClickListener() {
@Override
tvResposta.setText("Boto No clicado");
}
});
mBox.show();
}
Chame o mtodo na opo Excluir do menu:

excluirCadastro();
break;
Execute a aplicao e selecione a opo Excluir do menu:
Ao selecionar um boto, a mensagem ser exibida no TextView:
Submenus
Um submenu nada mais do que um menu que se abre ao ser clicado em
algum dos itens. Sua utilizao recomendvel quando a aplicao possui
muitas funcionalidades, que podem ser agrupadas como submenus de um

menu principal.
Para adicionar um submenu, basta criar o elemento menu dentro de um
elemento item no arquivo de menu:
android:icon="@drawable/ic_menu_archive"></item>
android:icon="@drawable/ic_menu_edit"></item>
android:icon="@drawable/ic_menu_save"></item>
android:icon="@drawable/ic_menu_home"></item>
android:icon="@drawable/ic_menu_delete"></item>
android:icon="@drawable/ic_menu_more">
<menu>
<item android:id="@+id/menu_search"
android:title="@string/menu_search"
android:icon="@drawable/ic_menu_search"/>
<item android:id="@+id/menu_attachment"
android:title="@string/menu_attchment"
android:icon="@drawable/ic_menu_attachment"/>
</menu>
</item>
</menu>
Observe que o submenu foi adicionado dentro da opo Mais (menu_more):

android:icon="@drawable/ic_menu_more">
<menu>
</menu>
</item>
No preciso configurar nada na activity, basta executar a aplicao e clicar

na opo Mais para exibir o submenu:
Observe, na imagem acima, que apareceu uma nova tela em primeiro plano
com os itens do submenu.
Assim como o menu, quando um item do submenu selecionado o sistema ir
executar o mtodo onOptionsItemSelected. Desta forma, para programar a
resposta do submenu, basta adicionar no mtodo onOptionsItemSelected as
opes para identificar o item do submenu selecionado:
String msg = "";
mBox.setMessage("Selecionada a opo Arquivo");
@Override
}
});
mBox.show();
break;
case R.id.menu_edit:
msg = "Selecionada a opo Editar";
break;
case R.id.menu_save:
msg = "Selecionada a opo
break;
case R.id.menu_home:
break;
excluirCadastro();
break;
/*case R.id.menu_more:
msg = "Selecionado a opo
break;*/
case R.id.menu_search:
break;
case R.id.menu_attachment:
break;
}
tvResposta.setText(msg);
return true;
Salvar";
Home";
Mais";
Pesquisar";
Adicionar arquivo";
Repare as ltimas opes do switch:

/*case R.id.menu_more:
msg = "Selecionada a opo Mais";
break;*/
case R.id.menu_search:
msg = "Selecionada a opo Pesquisar";
break;
case R.id.menu_attachment:
msg = "Selecionada a opo Adicionar arquivo";
break;
As opes do submenu foram configuradas e a exibio da mensagem da

opo Mais do menu foi desabilitada.
Execute a aplicao e selecione a opo Mais:
Clique em alguma opo do menu:
Os itens do menu podem ser agrupados para configurar algumas das

caractersticas comuns aos vrios itens como, por exemplo, configurar todos os
itens para ficar invisveis ou desabilitados atravs dos atributos do grupo:
Faa este exemplo: configure todos para exibir um rdio:

<menu>
<group android:checkableBehavior="single" >
</group>
</menu>
Ao executar, observe que todas as opes do submenu que pertencem a este

grupo, passaram a ter um rdio:
Dispositivos sem botes fsicos

Em dispositivos que no possurem o boto fsico Menu, sero exibidos trs
pontos direita na Action Bar a barra no topo da aplicao, onde o menu
pode ser acessado:
possvel emular esse cenrio, definindo um dispositivo virtual com as

caractersticas de um dispositivo que no possui botes fsicos, como a
configurao abaixo:
Na hora de executar a aplicao necessrio definir essa opo de emulador.

Para isso, basta clicar com o boto direito do mouse sobre a aplicao,
selecionar Run As > Run Configurations. Na caixa de dilogo que abrir,
em Target, selecione o nome emulador:
Clique em Run para a aplicao ser executada:
Ao clicar nos trs pontos, o menu ser exibido da seguinte forma:
Tambm possvel exibir algumas opes do menu na Action Bar. Basta

definir, na propriedade android:showAsAction, o comportamento do item de
acordo com as opes abaixo:
ifRoom: Ser exibido se houver espao para isso.

withText: Exibir o ttulo do item, se houver espao.
never: Nunca ser exibido na Action Bar.
always: Sempre exibir o item na Action Bar. Se exibir mais itens do que o
espao disponvel, a Action Bar ser sobreposta por outra Action Bar. Esse
comportamento no recomendado.
collapseActionView: A view associada a esse item desomantvel
recurso introduzido na verso 14. (explicado no curso avanado).
Por exemplo, se alterar o menu para:
android:icon="@drawable/ic_menu_archive"
android:showAsAction="ifRoom|withText"></item>
android:icon="@drawable/ic_menu_edit"
android:showAsAction="ifRoom|withText"></item>
android:icon="@drawable/ic_menu_save"
android:showAsAction="never"></item>
android:icon="@drawable/ic_menu_home"
android:icon="@drawable/ic_menu_delete"
android:icon="@drawable/ic_menu_more"
android:showAsAction="never">
<menu>
<group android:checkableBehavior="single" >
</group>
</menu>
</item>
</menu>
Ele ser exibido da seguinte forma:
Note que o que no foi exibido no Action Bar continua disponvel no cone dos
trs pontos.
O emulador com essa configurao pesado, por isso altere novamente o
target da aplicao e defina o antigo emulador:
Continue acompanhando o curso.
Toast
Outra forma de notificar os usurios utilizar a classe Toast. O Toast um
tipo de popup que aparece na tela, sempre em primeiro plano como a caixa de
dilogo, por um perodo de tempo pr-definido.
Faa este exemplo: na activity Tela8, remova as linhas referentes caixa de
dilogo:
mBox.setMessage("Selecionada a opo Arquivo");
@Override

}
});
mBox.show();
break;
Adicione o seguinte cdigo:

String texto = "Selecionada a opo Arquivo";
Context context = getApplicationContext();
int duracao = Toast.LENGTH_LONG;
Toast toast = Toast.makeText(context, texto, duracao);
toast.show();
break;
Repare que primeiro foi criado este texto:

String texto = "Selecionada a opo Arquivo";
Logo em seguida, foi pego o contexto em que a notificao ir aparecer:

Context context = getApplicationContext();
Ou seja, o contexto da aplicao.

Depois foi definida a durao da notificao:
int duracao = Toast.LENGTH_LONG;
Com as variveis acima, foi criado o Toast:

Toast toast = Toast.makeText(context, texto, duracao);
E exibido:
toast.show();
Execute o aplicao, exiba o menu e clique na opo Arquivo:
Intent
uma estrutura de dados passiva que comporta uma descrio abstrata da
operao a ser realizada. O Android utiliza os Intents para enviar mensagens
entre os trs principais componentes de uma aplicao (activitys, services e
broadcast receivers). Essas mensagens podem ser enviadas dentro da mesma
aplicao ou entre aplicaes diferentes.
Por exemplo, possvel abrir uma nova activity com o seguinte cdigo:
Intent intencao = new Intent(this, Tela2.class);
startActivity(intencao);
}
J para abrir outra aplicao como, por exemplo, o discador, utilize o cdigo
abaixo:
Intent intencao = new Intent(Intent.ACTION_DIAL, Uri.parse("tel:05501126267282"));
}
Adicione um boto no arquivo de layout do menu:

<TextView
<TextView
<Button
android:id="@+id/buttonDiscar"
android:layout_alignLeft="@+id/textViewResposta"
android:layout_below="@+id/textViewResposta"
android:text="@string/botao_discar" />
</RelativeLayout>
Agora,
na
activity,
implemente
a
interface onClickListener no
mtodo setOnClickListener. Dentro do mtodo onClick, coloque o cdigo
para abrir o discador do celular:
Button btnDiscar = (Button) findViewById(R.id.buttonDiscar);
btnDiscar.setOnClickListener(new View.OnClickListener() {
@Override
}
});
Execute a aplicao:
Ao clicar no boto Discar, o discador do celular ser aberto:
Intent implcitas e explcitas

Observe que o cdigo no informa uma classe:
Isso porque foi utilizado outro grupo de Intent, ou Intents implcitas, onde a
classe-alvo no nomeada. Ou seja: nas Intents implcitas no informado ao
sistema operacional qual a classe Java (seja uma activity, service ou broadcast
receiver) ser chamada. Ao invs disso um comando ou ao informado,
como no cdigo acima (ou um filtro, explicado frente). No cdigo acima, no
caso das Intents implcitas, tambm permitido, opcionalmente, informar a URI

que ser utilizada para realizar a ao.
O primeiro exemplo de Intent:
Intent intencao = new Intent(this, Tela2.class);
Refere-se ao grupo de Intent explcitas, ou seja: preciso informar

exatamente o nome da classe que se quer abrir.
Como voc deve ter reparado, as Intent explcitas so utilizadas para a
comunicao interna de uma aplicao; e as implcitas, para comunicao com
aplicaes externas.
Intent Filters
As atividades, servios e broadcast receivers podem ter um ou mais intent
filters para informar ao sistema quais intents implcitaspodem ser
manuseadas. Cada filtro descreve a capacidade que o componente, ou um
conjunto de intents, poder receber. Isso, em efeito, filtra intents de um tipo
desejado enquanto filtra intents no requeridos mas apenas intents implcitas
no requeridas. Uma intent explcita sempre entregue a seu alvo, no
importa o que contenha. O filtro simplesmente no consultado. Mas uma
intent implcita entregue a um componente apenas se puder passar por
algum dos filtros do componente que se quer que seja o alvo.
Assim como outras informaes essenciais a respeito da aplicao, as Intent
filters so declaradas no arquivo AndroidManifest.xml, como mostra o
cdigo abaixo:
<activity
<intent-filter>
</intent-filter>
</activity>
Note que a activity Tela8 (no caso a Activity inicial) possui uma tag onde os
filtros so criados em seu interior podem passar ao, dados ou categoria a
um objeto Intent. No exemplo acima, s foi criada uma ao (action), sendo
que atravs dela a activity localizada.
Voc dever criar um novo projeto para utilizar os filtros.

Feche o projeto atual, clique com o boto direito do mouse sobre o projeto e
selecione Close Project:
Crie um novo projeto e selecione a opo do menu File > New >
Android Application Project. A caixa de dilogo abaixo ser exibida:
Preencha os dados, conforme a imagem acima, e clique em Next:
Marque as opes, conforme a imagem acima, e clique em Next:
Marque as opes, conforme a imagem acima, e clique em Next:
Preencha os dados, conforme a imagem acima, e clique em Finish para criar o

projeto:
No layout activity_tela1.xml adicione um widget Button, dois TextView e

um EditText, conforme o cdigo abaixo:
<TextView
<EditText
android:ems="10"
android:text="@string/texto" >
<requestFocus />
</EditText>
<Button
android:id="@+id/buttonProxima"
android:text="@string/botao_proxima" />
<TextView
android:id="@+id/textViewRetorno"
android:layout_alignLeft="@+id/buttonProxima"
android:layout_below="@+id/buttonProxima"
android:layout_marginTop="15dp" />
</RelativeLayout>
Aproveite e crie um segundo arquivo de layout (activity_tela2.xml) com

dois TextViews, um Button e um EditText, conforme o seguinte cdigo:
<TextView
<EditText
android:id="@+id/editTextTexto"
android:layout_alignLeft="@+id/textViewResposta"
android:layout_below="@+id/textViewResposta"
android:ems="10"
android:text="@string/texto" >
<requestFocus />
</EditText>
<Button
android:layout_alignLeft="@+id/editTextTexto"
android:layout_below="@+id/editTextTexto"
<TextView
android:id="@+id/textViewRetorno"
android:layout_alignLeft="@+id/buttonVoltar"
android:layout_below="@+id/buttonVoltar"
android:layout_marginTop="15dp" />
</RelativeLayout>
Para abrir este layout preciso criar a activity abaixo:

@Override
}
}
Mapeie a activity, no AndroidManifest.xml, da seguinte forma:

<uses-sdk
<application
<activity
<intent-filter>
</intent-filter>
</activity>
<activity
android:exported="false">
<intent-filter>
<action android:name="br.com.treinaweb.action.SUBACTIVITY" />
<category android:name="android.intent.category.DEFAULT" />
</intent-filter>
</activity>
</application>
</manifest>
Note a opo action dentro das tags:

<intent-filter>
</intent-filter>
Nessa opo foi criada a ao que ser utilizada para referenciar a activity
quando for chamada no cdigo, conforme mostra o exemplo abaixo:
import android.content.Intent;
@Override
Button btnProxima = (Button) findViewById(R.id.buttonProxima);
btnProxima.setOnClickListener(this);
}
@Override
return true;
}
@Override
Intent intencao = new Intent("br.com.treinaweb.action.SUBACTIVITY");
}
}
Note que desta vez no foi preciso informar o nome da classe, apenas o nome
da ao definida no AndroidManifest.xml:
Execute a aplicao e clique no boto:
Enviando dados para outra activity

J foi explicado que, para enviar dados para outra activity, preciso criar
um Bundle, adicionar os dados no padro chave/valor e adicionar
o Bundle na Intent, desta forma:
String nome = txtNome.getText().toString();
Bundle parametros = new Bundle();
parametros.putString("nome", nome);
intencao.putExtras(parametros);
}
Mas tambm possvel adicionar os dados diretamente na Intent com o

mtodo putExtra, da seguinte forma:
intencao.putExtra("nome", nome);
}
J na activity que est recebendo os dados, o cdigo no muda:

Intent intencao = getIntent();
Bundle extras = intencao.getExtras();
if(extras == null) return;
String nome = extras.getString("nome");
if(nome != null) {
TextView tTitulo = (TextView) findViewById(R.id.textViewResposta);
tTitulo.setText(nome + " digite algo abaixo:");
}
}
preciso pegar a Intent atual:

Com ela, pegam-se os Extras:

Como a activity pode ser chamada por qualquer aplicao que informe a sua
ao
(br.com.treinaweb.action.SUBACTIVITY)
deve-se
verificar
se
o Bundle null, ou seja: se no possui nenhum valor:
Nesse caso, execute o return para finalizar a execuo do evento onCreate.

Logo em seguida, pegue o valor da chave nome:
Depois verifique se a chave possui valor:

if(nome != null) {
Se possuir, adicione o valor ao TextView:

Note tambm, no cdigo acima, que o boto foi vinculado ao evento Click:
No mtodo onClick coloque o mtodo finish() para voltar para a activity

anterior:
finish();
}
Adicione esse cdigo na aplicao e execute o projeto:
Digite o seu nome e clique em Prxima:
Para finalizar e voltar, basta clicar no boto Voltar:
Recebendo dados de outra activity

Da mesma forma que os dados podem ser enviados para outra activity na hora
em que est sendo chamada, tambm podem retornar para a activity que
chamou a subactivity no momento em que fechada.
Obs: Quando uma activity retorna dados, chamada de subactivity.
Primeiro chame a subactivity com o mtodo startActivityForResult:
startActivityForResult(intencao, REQUEST_CODE);
Note que o mtodo recebe opcionalmente um segundo parmetro,

o requestCode; se ele for positivo, e no ocorrer nenhum erro na subactivity,
ser retornado junto com os dados da subactivity. Esse cdigo utilizado para
identificar a subactivity na hora em que est retornando um dado, j que no
existe limite de quantas subactivities podem ser chamadas por uma activity.
preciso retornar os dados na subactivity antes de finaliz-la, com o
mtodo setResult(resultCode,
data).
Onde resultCode pode
serRESULT_CANCELED ou RESULT_OK, e data uma Intent com os dados
que sero retornados.
Observe que o mtodo no recebe um identificador da subactivity. Por isso,
o REQUEST_CODE foi utilizado no mtodo acima.
O cdigo na subactivity fica da seguinte forma:
@Override
if(nome != null) {
}
}
@Override
Intent data = new Intent();
EditText eTexto = (EditText) findViewById(R.id.editTextTexto);
String texto = eTexto.getText().toString();
data.putExtra("texto", texto);
setResult(RESULT_OK, data);
finish();
}
}
Note o cdigo do mtodo onClick:

finish();
}
Observe que foi criada uma Intent:

Foi pego o texto do EditText:

E atribudo Intent:
Depois foi passado para o mtodo setResult:

Para encerrar, finalizou-se a subactivity:

finish();
preciso chamar o mtodo setResult antes do mtodo finish; caso contrrio,

no ser executado.
J na activity preciso implementar o mtodo onActivityResult. Esse mtodo
sempre ser chamado quando uma subactivity retornar informaes. Veja o
cdigo abaixo:
protected void onActivityResult(int requestCode, int resultCode, Intent data){
switch(requestCode){
case REQUEST_CODE:
TextView result = (TextView) findViewById(R.id.textViewRetorno);
if(resultCode == RESULT_OK)
if(data.hasExtra("texto"))
result.setText(data.getExtras().getString("texto"));
break;
}
}
Observe que, primeiro, foi implementado um switch:

Desta forma, pode-se verificar todas as subactivities que a activity chamar.

Logo em seguida, verifica-se se a subactivity chamada:
case REQUEST_CODE:
Se for, verifica-se se ele retornou corretamente os dados:

Se estiver tudo certo, verifica-se se possui o dados; se sim, atribui-se

ao TextView:
Obs: Como a subactivity no ser executada em modal pode retornar os dados

assincronamente, mesmo sem a interao do usurio como, por exemplo,
verificar um sms.
O cdigo completo da classe ficar da seguinte forma:
final int REQUEST_CODE = 1;
@Override
Button btnProxima = (Button) findViewById(R.id.buttonProxima);
btnProxima.setOnClickListener(this);
}
@Override
return true;
}
@Override
intencao.putExtra("nome", nome);
startActivityForResult(intencao, REQUEST_CODE);
}
case REQUEST_CODE:
TextView result = (TextView) findViewById(R.id.textViewRetorno);
break;
}
}
}
Execute a aplicao, preencha seu nome e clique em Prximo:
Preencha algo:
Clique em Voltar:
Intents implcitas disponveis

No comeo do tpico sobre Intents foi explicado como abrir o discador do
celular utilizando a ao ACTION_DIAL. Dessa mesma forma podem ser
utilizadas outras aes que o Android disponibiliza para ter acesso s demais
funes do sistema operacional e do aparelho.
As aes disponveis mais utilizadas so:
ACTION_VIEW: Utilizado para visualizar o navegador, o mapa, os

contatos e o discador. A opo correta ser exibida de acordo com as
informaes do parmetro URI.
ACTION_DIAL: Exibe o discador.
ACTION_CALL: Efetua uma chamada para o nmero informado.
ACTION_EDIT: Exibe o editor de contatos do contado informado.
ACTION_PICK: Retorna dados de acordo com o cursor selecionado.

Para
visualizar
todas
as
aes
disponveis,
acesse
link: http://developer.android.com/reference/android/content/Intent.html
Acompanhe mais alguns exemplos, executando-os.
Efetuando uma chamada com um contato

da agenda
Para efetuar uma chamada utilizando um contato do celular, primeiro crie novo
arquivo de layout, conforme o seguinte cdigo:
<TextView
android:text="@string/rotulo" />
<ListView
android:id="@+id/listViewContatos"
android:layout_below="@+id/textViewTitulo" >
</ListView>
</RelativeLayout>
Note que foi utilizado um ListView para listar os contatos.

Para chamar o arquivo
activity Tela3.java abaixo:
de
layout
carregar
os
contados,
}
}
Antes de carregar o contato, crie a classe Contact.java abaixo:

package br.com.treinaweb.classes;
public class Contact {
private String contactId;
private String name;
private String number;
public String getContactId() {
return contactId;
}
public void setContactId(String contactId) {
this.contactId = contactId;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
crie
@Override
public String toString(){
return name + ": " + number;
}
Utilize essa classe para organizar os contatos. Ela no a melhor forma, como
ser explicado adiante, porque um contato pode ter mais de um nmero de
telefone. Ento, alguns contatos tero o mesmo nome, mas nmeros de
telefone diferentes. Como este exemplo simples, voc no precisa se
preocupar com esse detalhe.
Observe que o mtodo toString(), da classe objeto, foi sobescrito:
@Override
public String toString(){
return name + ": " + number;
}
Assim possvel controlar a exibio da classe Contact no widget ListView.

J para carregar os contatos, preciso criar o mtodo getContacts() na
activity Tela3 conforme o cdigo abaixo:
private List<Contact> getContacts(){
List<Contact> contacts = new ArrayList<Contact>();
try{
Cursor contact = getContentResolver().query(ContactsContract.Contacts.CONTENT_URI,
null, null, null, null);
while(contact.moveToNext()){
int indexContactID = contact.getColumnIndex(ContactsContract.Contacts._ID);
String ContactID = contact.getString(indexContactID);
int indexDisplayName = contact.getColumnIndex(ContactsContract.Contacts.DISPLAY_
NAME);
String name = contact.getString(indexDisplayName);
int indexHasPhone = contact.getColumnIndex(ContactsContract.Contacts.HAS_PHONE_
NUMBER);
int hasPhone = contact.getInt(indexHasPhone);
if(hasPhone == 1){
Cursor phoneCursor = getContentResolver().query(
ContactsContract.CommonDataKinds.Phone.CONTENT_URI, null,
ContactsContract.CommonDataKinds.Phone.CONTACT_ID+"='"+ContactID+"'", null
, null);
while(phoneCursor.moveToNext()){
int indexNumber = phoneCursor.getColumnIndex(ContactsContract.CommonDataKin
ds.Phone.NUMBER);
String number = phoneCursor.getString(indexNumber);
Contact oContact = new Contact();
oContact.setContactId(ContactID);
oContact.setName(name);
oContact.setNumber(number);
contacts.add(oContact);
}
phoneCursor.close();
}else{
}
}
contact.close();
}catch (Exception e) {
e.printStackTrace();
}
return contacts;
Primeiro foi criado um List de contatos, contendo todos os contatos:

List<Contact> contacts = new ArrayList<Contact>();
Depois, para percorrer os contatos do celular, foi criado um cursor:

Cursor contact = getContentResolver().query(ContactsContract.Contacts.CONTENT_URI, nu
ll, null, null, null);
Para acessar os elementos do cursor foi cirado um lao while:

while(contact.moveToNext()){
Logo em seguida, declarou-se um inteiro para armazenar o ndice da

coluna ID do cursor:
int indexContactID = contact.getColumnIndex(ContactsContract.Contacts._ID);
Que foi utilizado para pegar o ID do contato:

String ContactID = contact.getString(indexContactID);
O
mesmo
procedimento
o HAS_PHONE_NUMBER:
foi
repetido
para
pegar
o Nome e
int indexDisplayName = contact.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAM

E);
String name = contact.getString(indexDisplayName);
int indexHasPhone = contact.getColumnIndex(ContactsContract.Contacts.HAS_PHONE_NU
MBER);
int hasPhone = contact.getInt(indexHasPhone);
O HAS_PHONE_NUMBER informa se o contato possui algum telefone. Se ele

possuir o HAS_PHONE_NUMBER, ter valor 1:
if(hasPhone == 1){
Como um contato pode ter mais de um nmero de telefone, foi criado mais um
cursor para percorrer os telefones do contato:
Cursor phoneCursor = getContentResolver().query(
ContactsContract.CommonDataKinds.Phone.CONTENT_URI, null,
ContactsContract.CommonDataKinds.Phone.CONTACT_ID+"='"+ContactID+"'", null, nu
ll);
O lao while foi utilizado novamente para percorrer o cursor:

while(phoneCursor.moveToNext()){
Tambm foi pego o ndice da coluna Number e o nmero do contato:

int indexNumber = phoneCursor.getColumnIndex(ContactsContract.CommonDataKinds.Ph
one.NUMBER);
String number = phoneCursor.getString(indexNumber);
Logo em seguida, foi criada uma instncia da classe Contact:

O id, nome e o nmero do contato, foi setado no objeto da classe:

oContact.setNumber(number);
E adicionado na lista o objeto da classe:

Fora do lao while do nmero de telefone, o cursor foi fechado:

phoneCursor.close();
Se o contato no possuir telefone criada uma nova instncia; o id e nome do

contato so setados ao objeto e adicionados na lista:
Antes de retornar os dados, feche o cursor de contatos:

contact.close();
Para finalizar, retorne a lista:

return contacts;
Para carregar a lista, adicione o cdigo abaixo no mtodo onCreate:

List<Contact> contatos = getContacts();
ArrayAdapter<Contact> oAdapter = new ArrayAdapter<Contact>(this, android.R.layout.s
imple_gallery_item, contatos);
ListView list = (ListView) findViewById(R.id.listViewContatos);
list.setAdapter(oAdapter);
}
Para ler os contatos preciso adicionar, no AndroidManisfest.xml, a

permisso abaixo:
<uses-permission android:name="android.permission.READ_CONTACTS"/>
Entre as tags uses-sdk e application, conforme o seguinte cdigo:

<uses-sdk
<application
<activity
</activity>
<activity
<intent-filter>
</intent-filter>
</activity>
<activity
<intent-filter>
</intent-filter>
</activity>
</application>
</manifest>
Note, tambm, que a activity Tela3 j foi definida como inicial:

<activity
<intent-filter>
</intent-filter>
</activity>
Execute a aplicao:
Note que no foi listado nenhum contato porque, no moment,o no existe

nenhum cadastrado no emulador. Para exibi-los, clique no boto Home:
A pgina inical ser aberta. Nela, acesse o aplicativo Pessoas:
Para adicionar os contados no emulador:
Obs: O exemplo s ir funcionar se o emulador tiver algum contato

cadastrado.
Para pegar o nmero de telefone selecionado, preciso implementar na
activity a interface onItemClickListener, o mtodo onItemClick e associar o
evento ItemClick ao widget ListView, conforme o seguinte cdigo:
ArrayAdapter<Contact> oAdapter = new ArrayAdapter<Contact>(this, android.R.layout.
simple_gallery_item, contatos);
}
@Override
}
private List<Contact> getContacts(){
...
Obs: Esse s um fragmento do cdigo da classe.

J no mtodo onItemClick, adicione o cdigo abaixo:
Contact oContact = (Contact) parent.getItemAtPosition(position);
String number = oContact.getNumber();
Intent intent = new Intent(Intent.ACTION_CALL, Uri.parse("tel:"+number));
startActivity(intent);
}
Note que foi utilizada a ao ACTION_CALL. Dessa forma, o telefone ser

chamado sem a necessidade de passar pelo discador.
Como explicado no incio do curso, o Android separa todas as aplicaes e,

para uma aplicao acessar alguma rea do sistema operacional, necessrio
"pedir" permisso.
As permisses so informadas no arquivo AndroidManifest.xml, como foi
feito para ter acesso lista de contatos do celular. Com a lista de permisses
necessrias da aplicao, o sistema Android pergunta ao usurio, no momento
em que a aplicao est sendo instalada, se ele permite que ela tenha acesso
s reas solicitadas.
Para efetuar a ligao do nmero do telefone na aplicao, preciso inserir a
permisso CALL_PHONE no arquivo AndroidManisfest.xml, conforme o
seguinte cdigo:
<uses-sdk
<uses-permission android:name="android.permission.CALL_PHONE"/>
<application
<activity
</activity>
<activity
<intent-filter>
</intent-filter>
</activity>
<activity
<intent-filter>
</intent-filter>
</activity>
</application>
</manifest>
Para conhecer todas as permisses possveis, acesse a documentao oficial no

link:http://developer.android.com/reference/android/Manifest.permission.html
Agora execute a aplicao:
Clique em um contato e o nmero ser chamado:
Editando um contato
Existem duas formas de editar um contato: desenvolvendo uma tela para
editar e programar todas as funes; ou utilizar a tela de edio da rea de
contatos do Android.
A primeira opo explicada no curso intermedirio. Para utilizar a activity de
edio do Android, basta adicionar o cdigo abaixo:
String uri = ContactsContract.Contacts.CONTENT_URI + "/" + contactId;
Intent intent = new Intent(Intent.ACTION_EDIT, Uri.parse(uri));
intent.putExtra(INTENT_KEY_FINISH_ACTIVITY_ON_SAVE_COMPLETED, true);
startActivityForResult(intent, REQUEST_CODE);
O contactId o id do contato que se quer alterar. Como a

ao ACTION_EDIT ir utilizar a activity de edio do Android, no
necessrio colocar nenhuma permisso no arquivo AndroidManifest.xml.
A linha:
necessria devido a um bug no Android 4.0. Se ela no for adicionada nas

verses, ao final da edio, a aplicao da tela de edio no ser chamada.
Tambm adicione a propriedade abaixo na activity Tela3, que utilizada na
opo acima.
public static final String INTENT_KEY_FINISH_ACTIVITY_ON_SAVE_COMPLETED = "finishActiv
ityOnSaveCompleted";
Faa este exemplo: altere o mtodo onItemClick e adicione o cdigo abaixo:

Contact oContact = (Contact) parent.getItemAtPosition(position);
String contactId = oContact.getContactId();
String uri = ContactsContract.Contacts.CONTENT_URI + "/" + contactId;
Intent intent = new Intent(Intent.ACTION_EDIT, Uri.parse(uri));
startActivityForResult(intent, REQUEST_CODE);
}
Observe que foram passadas, no mtodo startActivityForResult, alm

da Intent, a varivel REQUEST_CODE criada no incio da classe:
final int REQUEST_CODE = 1;
...
Para verificar o retorno da activity, sobrescreva o mtodo onActivityResult:

case REQUEST_CODE:
if(resultCode == RESULT_OK){
ArrayAdapter<Contact> oAdapter = new ArrayAdapter<Contact>(this, android.R.layou
t.simple_gallery_item, contatos);
}
break;
}
}
Note que primeiro verificado se houve alguma alterao nos contatos. Se

sim, os contatos so listados novamente e o ListView carregado.
Execute a aplicao:
Clique em algum contato e a tela de edio ser aberta:
Efetue alguma alterao e clique em Done para voltar para a aplicao com a
alterao realizada:
BoadcastReceiver
Um aparelho de telefone, durante seu funcionamento, realiza diversos

eventos como receber e realizar uma chamada, carregar a bateria, enfim, o
tempo todo realiza alguma operao. No Android, para informar as aplicaes
sobre
quais
eventos
esto
sendo
executados,
ele
utilizada
o BroadcastReceiver.
O BroadcastReceiver tambm pode ser utilizado para que a aplicao seja
executada assim que um evento for executado. Para isso preciso criar uma
classe, que estende a classe BroadcastReceiver, e registrar o receptor
no AndroidManisfest.xml. Assim, toda vez que o evento escutado for
executado, o Android ir chamar a classe e executar o mtodo onReceive().
Faa este exemplo: crie outra aplicao, chamada TerceiroProjeto, conforme
as imagens a seguir:
Clique em Next:
Clique em Next:
Clique em Next:
Clique no boto Finish.

Como explicado acima, para criar um BroadcastReceiver preciso criar uma
classe que estende a classe BroadcastReceiver. Desta forma, crie uma classe
chamada Intercept conforme a imagem abaixo:
Clique em Finish para criar a classe:

import android.content.BroadcastReceiver;
import android.content.Context;
public class Intercept extends BroadcastReceiver {
@Override
public void onReceive(Context arg0, Intent arg1) {
}
}
O evento a ser escutado ser o recebimento de uma ligao. Neste caso,

preciso
registrar
o
receiver,
da
seguinte
forma,
no
arquivoAndroidManifest.xml:
<uses-sdk
<uses-permission android:name="android.permission.READ_PHONE_STATE" />
<uses-permission android:name="android.permission.READ_CONTACTS" />
<application
<activity
<intent-filter>
</intent-filter>
</activity>
<receiver android:name="br.com.treinaweb.parte3.Intercept">
<intent-filter>
<action android:name="android.intent.action.PHONE_STATE"/>
</intent-filter>
</receiver>
</application>
</manifest>
Note que, alm de registrar o receiver, tambm j foram adicionadas as

permisses necessrias para escutar o evento de alguma mudana no estado
do telefone e leitura de dados de contatos.
Volte ao receiver, no mtodo onReceive, e adicione o seguinte cdigo:
@Override
public void onReceive(Context context, Intent intent) {
Bundle extras = intent.getExtras();
if(extras == null)
return;
String state = extras.getString(TelephonyManager.EXTRA_STATE);
if (state.equals(TelephonyManager.EXTRA_STATE_RINGING)){
String phoneNumber = extras.getString(TelephonyManager.EXTRA_INCOMING_NUMBER)
;
String fromDisplayName = "Desconhecido";
Uri uri;
String[] projection;
uri = Uri.withAppendedPath(
ContactsContract.PhoneLookup.CONTENT_FILTER_URI,
Uri.encode(phoneNumber));
projection = new String [] { ContactsContract.PhoneLookup.DISPLAY_NAME };
Cursor cursor = context.getContentResolver().query(uri, projection, null, null, null);
if(cursor != null){
if(cursor.moveToFirst())
fromDisplayName = cursor.getString(0);
cursor.close();
}
Intent intencao = new Intent(context, Tela1.class);

intencao.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
intencao.putExtra("number", phoneNumber);
intencao.putExtra("name", fromDisplayName);
context.startActivity(intencao);
}
Onde, primeiro foram pegos os dados passados pela Intent:

Se ela no possuir nenhum dado, cancela-se a execuo do mtodo:

if(extras == null)
return;
Se ela possuir, pego o estado do telefone:

Verifica-se se o estado dele recebendo uma ligaco:

Se sim, pega-se o nmero de telefone:

String phoneNumber = extras.getString(TelephonyManager.EXTRA_INCOMING_NUMBER);
Em seguida, o nmero atribudo a um nome de remetente:

Adiante, ser verificado se o nmero do remetente se encontra na agenda de

contatos; se sim, este ser o nome atribudo varivelfromDisplayName.
Para pesquisar o contato, so criados o uri e o projection:
Uri uri;
E atribudos os valores s variveis:

Na primeira varivel foi criado um filtro para os contatos, de acordo com o

nmero de telefone da ligao. J na segunda, foi informado que se quer
apenas saber o nome do contato.
Foi criado um cursor para pesquisar os contatos do celular, de acordo com o
filtro:
Se ele encontrar algum contato pegar o nome retornado e atribuir

varivel fromDisplayName:
f(cursor != null){
cursor.close();
}
Com todos os dados cria-se uma Intent para a acitivity Tela1. Adicionam-se os
dados da mensagem e inicia-se a activity:
context.startActivity(intencao);
Para exibir a mensagem na activity, primeiro preciso

dois TextView no arquivo de layout, conforme o cdigo abaixo:
<TextView
adicionar
<TextView
android:id="@+id/textViewRemente"
android:text="@string/remetente" />
<TextView
android:id="@+id/textViewTelefone"
android:layout_alignLeft="@+id/textViewRemente"
android:layout_below="@+id/textViewRemente"
android:text="@string/numero" />
</RelativeLayout>
No evento onCreate da activity, adicione o seguinte cdigo:

@Override
Bundle extra = getIntent().getExtras();
if(extra == null)
return;
TextView viewRemetente = (TextView) findViewById(R.id.textViewRemente);
TextView viewNumero = (TextView) findViewById(R.id.textViewTelefone);
String remetente = "";
String numero = "";
if(extra.getString("name") != null){
remetente = "Remetente: " + extra.getString("name");
numero = "Nmero: " + extra.getString("number");
}else{
remetente = "Nenhuma ligao recebida";
}
viewRemetente.setText(remetente);
viewNumero.setText(numero);
}
Agora execute a aplicao para instal-la no emulador:
Agora preciso emular uma ligao para testar o aplicativo.

No Eclipse, selecione a opo Window > Show View > Other:
Selecione a opo Emulador Control e clique em OK para exibir a seguinte

aba no Eclipse:
No grupo Telephony Actions, no campo Incoming number, informe um

nmero de telefone (pode ser um telefone falso) e selecione a opo Voice,
conforme a imagem abaixo:
Clique em Call para efetuar a ligao. Como a ligao executa outra aplicao,
antes de ela ser mostrada, a aplicao exibir os dados no emulador:
E ir exibir o aplicativo Telefone:
Como a aplicao foi aberta um pouco antes, ser exibida novamente quando
a ligao for finalizada:
Se o nmero chamado for de algum contato, o respectivo nome ser exibido:
Notificao
Para definir uma notificao da barra de status (no topo da tela), uma janela de
Notificaes e quaisquer outras configuraes de alerta, usa-se a
classe Notification.
Para criar uma notificao da barra de status necessrio ter:
Um cone.
O contedo da notificao.
Um PedingIntent, que ser adicionado quando a notificao for
selecionada.
Como cone use:
Contido na pasta .. sdk\platforms\android-17\data\res.

Na pasta de cones do projeto (C:\Curso\Android\cones), crie uma pasta
chamada ic_notify:
Dentro dela crie mais quatro pastas, conforme mostra a imagem abaixo:
Em cada pasta, coloque o cone stat_sys_phone_call.png, de acordo com a

sua resoluo:
Adicione as quatro imagens nas respectivas pastas do projeto, conforme indica

a imagem abaixo:
Volte ao cdigo.
A primeira coisa a criar um objeto NotificationManager:
NotificationManager mNotificationManager = (NotificationManager) context.getSystemSer
vice(Context.NOTIFICATION_SERV
ICE);
Na linha seguinte criado o PedingIntent:

PendingIntent contentIntent = PendingIntent.getActivity(context, 0, intencao, 0);
O PedingIntent uma referncia de uma Intent; no caso deste exemplo,

referncia activity Tela1 que ser aberta quando o usurio clicar na
mensagem de notificao.
Em seguida so definidos os outros valores a serem apresentados na tela de
notificao:
int icon = R.drawable.stat_sys_phone_call;
String titulo = "Telefonena de " + fromDisplayName;
String texto = "Ligao de " + fromDisplayName + " - " + phoneNumber;
long quando = System.currentTimeMillis();
A primeira varivel o cone; a segunda, o ttulo da mensagem que ser

exibida; a terceira, o texto da mensagem; e a quarta, contm o tempo corrente
para informar ao usurio o horrio em que a notificao foi ativada.
Logo em seguida, utiliza-se o NotificationCompat.Builder para criar um
construtor para a notificao:
NotificationCompat.Builder builder = new NotificationCompat.Builder(context);
Antes era utilizado o prprio constructor da classe Notification, mas essa

opo est obsoleta desde a verso 11 do Android. Agora necessrio
utilizar NotificationCompat.Builder para que a notificao seja compatvel
com qualquer verso Android. Se o aplicativo for desenvolvido para a verso
16 (Android 4.1) ou superior, possvel utilizar a classe Builder presente
em Notification.
So definidas, nos mtodos de builder, as informaes da mensagem:
builder.setContentIntent(contentIntent)
.setContentTitle(titulo)
.setContentText(texto)
.setSmallIcon(icon)
.setWhen(quando);
Com esses dados, a notificao criada:

Notification notification = builder.build();
Para finalizar, cria-se um id para a notificao e a inicia-se:

final int APP_NOTIFICATION_ID = 1;
mNotificationManager.notify(APP_NOTIFICATION_ID, notification);
Veja o cdigo completo da classe:

import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.database.Cursor;
import android.net.Uri;
import android.provider.ContactsContract;
import android.support.v4.app.NotificationCompat;
import android.telephony.TelephonyManager;
public class Intercept extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
if(extras == null)
return;
String phoneNumber = extras.getString(TelephonyManager.EXTRA_INCOMING_NUMBER

);

Uri uri;
if(cursor != null){
cursor.close();
}
NotificationManager mNotificationManager = (NotificationManager) context.getSystem
Service(Context.NOTIFICATION_SERVICE);
PendingIntent contentIntent = PendingIntent.getActivity(context, 0, intencao, 0);
int icon = R.drawable.stat_sys_phone_call;
String titulo = "Telefonena de " + fromDisplayName;
String texto = "Ligao de " + fromDisplayName + " - " + phoneNumber;
long quando = System.currentTimeMillis();
NotificationCompat.Builder builder = new NotificationCompat.Builder(context);
builder.setContentIntent(contentIntent)
.setContentTitle(titulo)
.setContentText(texto)
.setSmallIcon(icon)
.setWhen(quando);
Notification notification = builder.build();
final int APP_NOTIFICATION_ID = 1;
mNotificationManager.notify(APP_NOTIFICATION_ID, notification);
}
}
}
Execute o projeto:
Na aba Emulador Control, no grupo Telephony Actions:
Enfetue uma ligao:
Observe que a notificao aparece na barra de status. Se verificar, a

notificao ficar visvel:
Ao clicar na notificao a acitivity aberta:

Curso de Android Básico

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Curso de Android Básico

Uploaded by

Copyright:

Available Formats

Sumrio

Open Handset Alliance

O Android um sistema operacional mvel completo e aberto, desenvolvido

Ele foi desenvolvido com a inteno de permitir aos desenvolvedores criar

Android, como: um cliente de e-mail, mapas, navegadores, calendrios,

A pequena camada do ambiente de execuo (Android Runtime) uma

Algumas opes da loja esto disponveis apenas em alguns mercados.

Espao livre em disco de 1 GB aproximadamente.

Para configurar o ambiente, voc pode seguir esta ordem:

Instalao do SDK do Java

Sempre baixe a ltima verso do JDK primeiro cone na imagem acima. Ao

Aceite os termos e baixe a verso de acordo com o seu sistema operacional. A

Clique na opo Sistema e Segurana (System and Security):

Nessa tela, selecione a opo Sistema (System):

Nessa tela, clique na opo Configuraes avanadas do sistema (Advanced

Nessa caixa de dilogo, clique no boto Variveis de Ambiente (Environment

Agora, para o usurio local (o primeiro box), adicione trs variveis de

Na caixa de dilogo que surgir, adicione a varivel JAVA_PATH:

Leia os termos de uso. Se concordar, marque a opo I have read and...,

Instalando o Android SDK

Note que dentro da pasta esto duas pastas e o SDK Manager:

A aplicao abaixo ser aberta:

Em seguida, clique no boto Install X package:

Esse boto sempre ir exibir a quantidade de pacotes a serem instalados. Ao

Os pacotes a serem instalados so detalhados e a licena de uso exibida.

Em seguida, clique em Install para instalar os pacotes:

Os pacotes sero baixados e instalados:

Primeiro Exemplo Android

Ao ser executado, a tela abaixo ser exibida:

Nela, selecione a pasta de trabalho (o local onde os projetos sero criados), e

Por estar tudo configurado, voc j pode criar o projeto.

A tela New Android Application ser aberta:

Nessa tela, preencha as seguintes informaes:

Em Application Name digite Primeiro Projeto (esse nome ir

Em Theme selecione Holo Light with... (Esse ser o tema da aplicao

Primeiro Exemplo Android

Ao ser executado, a tela abaixo ser exibida:

Nela, selecione a pasta de trabalho (o local onde os projetos sero criados), e

Por estar tudo configurado, voc j pode criar o projeto.

A tela New Android Application ser aberta:

Nessa tela, preencha as seguintes informaes:

Em Application Name digite Primeiro Projeto (esse nome ir

Em Theme selecione Holo Light with... (Esse ser o tema da aplicao

Nessa tela voc definir qual ser o template utilizado na criao

Nessa tela, preencha com as seguintes informaes:

Em Activity Name informe Tela1 (esse ser o nome da classe Java da

Entendendo o Projeto Android

A primeira pasta a src; nela ficam contidas as classes em Java. Ao expandi-la,

O nome do pacote foi a informao adicionada na opo Package name, na

Obs: O cdigo pode ser um pouco diferente, dependendo da verso do Android

criada pelo template e no deve ser alterada manualmente, muito menos os

Por exemplo, para fazer referncia

Voc at pode a abrir o arquivo R.java:

Essa biblioteca contm todos os pacotes e respectivas classes do Android.

O arquivo android-support-v4.jar contm bibliotecas de apoio, permitindo

Voc aprender a gerenciar os recursos dessa pasta nos prximos cursos.

Se for a primeira vez que voc executa o projeto, o emulador ir demorar

Ela indica que o emulador est sendo carregado. Ao terminar o carregamento,

O emulador semelhante ao celular. Nesse caso necessrio desbloquear o

A aplicao ser exibida:

Obs: No feche o emulador (caso contrrio, voc ter que esperar o

Ela funciona como o output do emulador. Todo retorno do emulador

Processo de execuo do projeto