SumárioIntrodução.............................................................................................................................................2

Arquitetura..............................................................................................................................................3

Google Play..............................................................................................................................................6

Montando o Ambiente............................................................................................................................8

Instalação 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 execução do projeto.........................................................................................................39

Adicionando novos recursos................................................................................................................42

Adicionando recursos diretamente no xml.........................................................................................43

Adicionando recurso no modo design.................................................................................................44

Adicionando Widgets à aplicação........................................................................................................46

TextView................................................................................................................................................47

Executando o projeto Android.............................................................................................................50

Trabalhando com eventos....................................................................................................................51

Adicionando Eventos............................................................................................................................56

Associando o evento ao botão..............................................................................................................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

Resolução do Emulador........................................................................................................................87

RelativeLayout......................................................................................................................................91

FrameLayout.........................................................................................................................................92

ScrollView..............................................................................................................................................94

Usando Widgets de Seleção..................................................................................................................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 Gráficos................................................................................................................................116

Ícones de exemplo...............................................................................................................................118

Recursos de Menu...............................................................................................................................122

Preparando o exemplo........................................................................................................................125

Carregando o menu.............................................................................................................................126

Em execução........................................................................................................................................127

Programando o menu.........................................................................................................................129

Caixa de diálogo..................................................................................................................................130

Configurando a janela de confirmação..............................................................................................133

Submenus............................................................................................................................................134

Dispositivos sem botões físicos......................................................................................................139

Toast....................................................................................................................................................144

Intent...................................................................................................................................................146

Intent Filters........................................................................................................................................150

Enviando dados para outra activity...................................................................................................158

Recebendo dados de outra activity....................................................................................................161

Intents implícitas disponíveis........................................................................................................165

Editando um contato...........................................................................................................................175

BoadcastReceiver................................................................................................................................177

Notificação.........................................................................................................................................189

IntroduçãoA 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 número 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 países em desenvolvimento atualizam seus aparelhos por modelos mais recentes.

Em mercado tão promissor, não restam dúvidas que inovações nessa área são inevitáveis.

Tendo como motivação principal a inovação na área de telefonia celular, várias empresas do ramo de telefonia e tecnologia, com o apoio do Google, criaram uma parceria que deu origem à Open Handset Alliance – OHA.

Open Handset AllianceA Open Handset Alliance é um grupo de empresas que se uniram para acelerar a inovação nos dispositivos móveis. Muitos acreditam que o Google, por ser a empresa líder dos projetos, é o único a investir nos projetos do grupo.

A intenção inicial da organização era construir um sistema operacional de código aberto, onde qualquer software instalado no aparelho tivesse o mesmo privilégio que os aplicativos criados ou licenciados pelo fabricante, sendo possível a total integração e customização 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 sobre essa aliança no site: http://www.openhandsetalliance.com/

O Android é um sistema operacional móvel completo e aberto, desenvolvido com base no sistema operacional Linux.

Ele foi desenvolvido com a intenção de permitir aos desenvolvedores criar aplicações móveis que pudessem tirar total proveito do que um aparelho móvel pudesse oferecer. Por exemplo, uma aplicação pode apelar para qualquer funcionalidade do telefone como efetuar chamadas,

enviar mensagens de texto ou utilizar a câmera – o que permite aos desenvolvedores adaptarem e evoluírem 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 evolução, já que a comunidade trabalha em conjunto para construir aplicações mais inovadoras.

Apesar de ter sido construído com base no Linux, ele não possui windowing system nativo, suporte a glibc ou algum dos conjuntos de padrões apresentados em determinadas distribuições Linux.

Uma dúvida comum é quanto à segurança do sistema operacional. Você deve estar se perguntando: já que qualquer um pode modificar os componentes, o que impede que alguém faça um software malicioso e acesse informações pessoais do seu dispositivo? Bem, o Android conta com um sistema de segurança muito forte. Por ser executado , todas as vezes que um aplicativo for instalado em um aparelho Android, será criado um novo usuário Linux para aquele aplicativo, com diretórios que serão usados pelo aplicativo, mas somente por aquele usuário Linux. Como os aplicativos ficam completamente isolados uns dos outros, para qualquer tentativa de acessar informações de outro aplicativo, será necessário ter explicitamente a autorização do usuário, podendo ser negada ou autorizada a instalação do aplicativo, através dos mecanismos de permissão.

Cada processo da aplicação no Android é considerado uma sandbox. Só será possível acessar outras aplicações caso as permissões sejam explicitamente declaradas – o que é necessário para que possam ser conhecidas desde o momento da instalação. Nada irá fazer com que sejam alteradas, depois disso.

Toda aplicação Android precisa ser assinada com um certificado cuja chave privada é mantida por seu desenvolvedor. Não é necessário que este certificado seja assinado por uma autoridade de certificação, pois funciona somente para estabelecer relações de confiança entre as aplicações.

Para desenvolver aplicações para o Android é utilizado o kit de desenvolvimento Android SDK, que disponibiliza as ferramentas e APIs necessárias, utilizando o Java como linguagem.

ArquiteturaNa imagem abaixo você pode ver como é estruturada a arquitetura do Android:

Ele possui as camadas: Applications, Application Frameworks, Libraries, Android Runtime e Linux Kernel.

ApplicationsAcima 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, calendários, 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 máquina virtual Dalvik. Lembrando que uma aplicação não precisa obrigatoriamente ser escrita para o Android, já que o Java possui grande portabilidade. Outras aplicações escritas em Java podem ser incorporadas ao Android.

Application FrameworkNa camada do framework (Application Framework) estão todas as APIs e recursos utilizados pelos aplicativos: as classes visuais que incluem listas, grades, caixas de texto, botões e até um navegador web embutido – View System (componentes utilizados na construção de aplicativos); provedor de conteúdo (Content Provider) que possibilita, à determinada aplicação, acessar informações de outra aplicação, ou até compartilharem informações, possibilitando a troca de informações entre aplicativos e gerenciadores de recursos, gerenciador de localizações (GPS e Cell ID), gerenciador de notificação (fornece informações sobre eventos que ocorrem no dispositivo), de pacotes e de atividade que controla todo o ciclo de vida da aplicação e o acesso e navegação entre as aplicações.

Todos os conjuntos de componentes disponíveis na plataforma Android possuem pleno acesso às APIs utilizadas pelo núcleo da plataforma. Esta arquitetura foi projetada para simplificar a reutilização de componentes, onde qualquer aplicação pode usar recursos de outra, desde que respeite às restrições de segurança.

LibrariesA camada de bibliotecas (Libraries) carrega consigo um conjunto de bibliotecas C/C++ utilizadas pelo sistema – incluídas nesse conjunto a biblioteca C padrão (Libc) – e possui ainda aquelas bibliotecas das áreas de multimídia, visualização de camadas 2D e 3D, funções para navegadores web, funções para gráficos, funções de aceleração de hardware, renderização 3D, fontes bitmap e vetorizadas e funções de acesso ao banco de dados SQLite. Tais recursos estão disponíveis no framework para o desenvolvimento de aplicativos.

Android RuntimeA pequena camada do ambiente de execução (Android Runtime) é uma instância da máquina virtual Dalvik, criada para cada aplicação executada no Android. A Dalvik é uma máquina virtual com melhor desempenho, maior integração com a nova geração de hardware e projetada para executar várias máquinas virtuais paralelamente. Foi projetada para funcionar em sistemas com baixa frequência de CPU, pouca memória RAM disponível e sistema operacional sem espaço de Swap. Além disso, é otimizada para o consumo mínimo de memória, bateria e CPU.

O Libraries Core inclui um grupo de bibliotecas que fornece a maioria das funcionalidades disponíveis nas principais bibliotecas da linguagem Java, como estruturas de dados, acesso a arquivos, acesso a redes e gráficos.

Aplicações escritas em Java são compiladas e executadas usando a Máquina Virtual Dalvik, desenvolvida para uso em dispositivos móveis, o que permite que programas sejam distribuídos em formato binário (bytecode) e possam rodar em qualquer dispositivo Android, independente do processador utilizado. Apesar de as aplicações Android serem escritas em Java, elas não rodam na máquina virtual do Java (JVM).

Linux Kernel

Utiliza a versão 2.6 do kernel do Linux para os serviços centrais do sistema, tais como segurança, gestão de memória, gestão de processos, pilha de protocolos de rede e modelo de drives. O kernel também atua como uma camada de abstração entre hardware e o resto da pilha de software. Um acessório interessante é o Binder (IPC), responsável por obter e enviar para a aplicação requerente a interface de serviço da aplicação requerida, possibilitando a Comunicação Inter-processos (IPC).

Google PlayO Google Play é uma evolução da Android Market, antiga loja de aplicativos Android desenvolvida pelo Google. Agora no Google Play, além de aplicativos, também é possível comprar/baixar livros (e-book), filmes, músicas, dispositivos e acessórios. Disponível no link:http://play.google.com/:

Algumas opções da loja estão disponíveis 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 dólares:

Android DevelopersO site Android Developers (http://developer.android.com/) contém todas as informações para oferecer suporte e auxiliar a desenvolver o Android:

Montando o AmbientePara desenvolver aplicações Android é utilizada a linguagem Java. Qualquer editor pode ser utilizado para desenvolver uma aplicação (até o bloco de notas, compilando na linha de comando do SO). Neste curso será usado o Eclipse, que é a IDE recomendada pelo Google.

Além dos diversos recursos do Eclipse, há um plugin específico 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 LinuxSoftware

JDK6 ou JDK7 Eclipse 3.6.2 (Helios) ou superior. Android Developer Tools – PluginHardware

Espaço livre em disco de 1 GB aproximadamente. Memória mínima de 1 GB.Para configurar o ambiente, você pode seguir esta ordem:

1- Instalação do SDK do Java. 2- Instalação do Eclipse. 3- Instalação do SDK do Android. 4- Instalação da plataforma do Android. 5- Instalação do Plugin Android para Eclipse.Obs: Para evitar qualquer tipo de conflito nos programas que serão instalados, desinstale qualquer versão antiga dos softwares listados. Ou utilize o ADT Bundle disponibilizado pelo Google, que traz as etapas 2 a 5 acima já configuradas. Essa é opção adotada neste curso.

Instalação do SDK do JavaPara efetuar o download do SDK do Java, acesse este endereço: http://www.oracle.com/technetwork/java/javase/downloads/index.html:

Sempre baixe a última versão do JDK – primeiro ícone na imagem acima. Ao clicar no ícone, a imagem abaixo será apresentada:

Aceite os termos e baixe a versão de acordo com o seu sistema operacional. A instalação não requer uma série complicada de passos, basta ir avançando até finalizar.

Configurando o JavaAntes de instalar o SDK do Android, será necessário configurar algumas variáveis de ambiente do Windows, incluindo a variávelJAVA_PATH, que será utilizada pelo SDK do Android.

Para o Windows 8, Windows 7 e Windows Vista, abra o Painel de Controle:

Clique na opção Sistema e Segurança (System and Security):

Nessa tela, selecione a opção Sistema (System):

Nessa tela, clique na opção Configurações avançadas do sistema (Advanced system settings) no lado esquerdo da imagem acima, para exibir a seguinte caixa de diálogo:

Nessa caixa de diálogo, clique no botão Variáveis de Ambiente (Environment Variables):

Agora, para o usuário local (o primeiro box), adicione três variáveis de Ambiente.

Clique no primeiro botão Novo...:

Na caixa de diálogo que surgir, adicione a variável JAVA_PATH:

Variável: 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 variável:

Android SDKPara baixar o Android SDK acesse o site: http://developer.android.com/sdk/index.html:

Agora o Google disponibiliza o ADT Bundle, que incluiu o Eclipse com o plugin ADT instalado, além do Android SDK, permitindo pular essa etapa do processo.

Clique em Download the SDK:

Leia os termos de uso. Se concordar, marque a opção “I have read and...”, selecione a versão do seu sistema operacional e efetue o download do ADT Bundle:

Instalando o Android SDKApós efetuar o download, desempacote o arquivo no local da sua preferência:

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

Nesse pacote tudo já está configurado, não sendo preciso fazer mais nada. Basta abrir o Eclipse para iniciar o desenvolvimento da aplicação.

Porém, antes de fazer isso conheça o SDK Manager, que é a ferramenta mais importante do SDK do Android.

SDK Manager

O SDK Manager permite gerenciar as várias versões disponíveis do SDK do Android. Para iniciá-lo, execute o arquivo SDK Manager.exe, presente na pasta do pacote:

A aplicação abaixo será aberta:

Ela lista todas as ferramentas disponíveis para o SDK, bem como todas as versões de SDK do Android para baixar.

Note que a versão 4.2 do Android já está instalada. No momento, essa é a versão mais atual. Mas para desenvolver uma aplicação para uma plataforma específica como, por exemplo, a 2.3, é necessário instalar essa versão do SDK. Selecione-a:

Em seguida, clique no botão Install X package:

Esse botão sempre irá exibir a quantidade de pacotes a serem instalados. Ao clicar nele, a caixa de diálogo abaixo será aberta:

Os pacotes a serem instalados são detalhados e a licença de uso é exibida. Para instalá-lo, é necessário 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 serão baixados e instalados:

Primeiro Exemplo AndroidPrimeiro é 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 serão criados), e clique em Ok. O Eclipse será carregado e aberto:

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

Como mostra a página de Boas-vindas (que pode ser fechada), para criar um projeto Android você deve selecionar a opção 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 informações:

Em Application Name digite Primeiro Projeto (esse nome irá identificar a aplicação, ou seja, será com ele que a aplicação será apresentada aos usuários). Em Project Name digite PrimeiroProjeto (esse nome, além 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 aplicação. É por isso que ele segue as mesmas regras do Java; ou seja, o domínio ao contrário). Em Minimum Required SDK selecione API 9: Android 2.3 (esse é o SDK mínimo para executar a aplicação). Em Target SDK selecione API 17: Android 4.2 (esse será o SDK ideal para a utilização da aplicação). Em Compile With selecione API 17: Android 4.2 (o SDK utilizado para compilar a aplicação. Ele deve ser igual ou superior ao SDK definido em Target SDK). Em Theme selecione Holo Light with... (Esse será o tema da aplicação e os widgets já serão formatados para esse tema).

Obs: Se for necessário modificar a plataforma no futuro, basta clicar com o botão direito do mouse sobre o projeto, no Package Explorer, e selecionar a opção Properties, depois selecionar Android e marcar a plataforma desejada.

Defina os valores, conforme a imagem abaixo:

Clique em Next:

Primeiro Exemplo AndroidPrimeiro é 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 serão criados), e clique em Ok. O Eclipse será carregado e aberto:

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

Como mostra a página de Boas-vindas (que pode ser fechada), para criar um projeto Android você deve selecionar a opção 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 informações:

Em Application Name digite Primeiro Projeto (esse nome irá identificar a aplicação, ou seja, será com ele que a aplicação será apresentada aos usuários). Em Project Name digite PrimeiroProjeto (esse nome, além 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 aplicação. É por isso que ele segue as mesmas regras do Java; ou seja, o domínio ao contrário). Em Minimum Required SDK selecione API 9: Android 2.3 (esse é o SDK mínimo para executar a aplicação). Em Target SDK selecione API 17: Android 4.2 (esse será o SDK ideal para a utilização da aplicação). Em Compile With selecione API 17: Android 4.2 (o SDK utilizado para compilar a aplicação. Ele deve ser igual ou superior ao SDK definido em Target SDK). Em Theme selecione Holo Light with... (Esse será o tema da aplicação e os widgets já serão formatados para esse tema).

Obs: Se for necessário modificar a plataforma no futuro, basta clicar com o botão direito do mouse sobre o projeto, no Package Explorer, e selecionar a opção 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 aplicação já será criada com uma tela (Create activity); e se a aplicação será uma biblioteca que poderá ser utilizada em outros projetos Android (Mark this project as libary). Também é permitido modificar o local do projeto, bem como definir se ele será incluído em um Working set (espaços de trabalho dentro do workspace).

Selecione as opções na tela, conforme indicado na imagem acima e clique em Next:

Nessa tela você definirá qual será o template utilizado na criação da Activity (tela). No caso deste exemplo, utilize a primeira opção (BlankActivity), conforme a imagem acima. Clique em Next:

Nessa tela, preencha com as seguintes informações:

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 navegação utilizada e, por enquanto, não será utilizada).Clique em Finish para criar o projeto:

Entendendo o Projeto AndroidObserve que no Package Explorer o projeto já foi criado com uma série 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 informação adicionada na opção Package name, na criação do aplicativo, e o nome da classe da Activity Name.

Dê um duplo clique no arquivo Tela1.java para abri-lo; será exibido o código abaixo:

Obs: O código pode ser um pouco diferente, dependendo da versão do Android utilizada na criação 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.

Não altere nada neste no momento.

A segunda pasta é a gen; nela ficam as classes em Java que contêm as constantes referentes aos recursos da aplicação. Ela também é uma classe criada pelo template e não deve ser alterada manualmente, muito menos os arquivos que ela contém:

Por exemplo, para fazer referência a um arquivo de layout (o arquivo activity_tela1.xml explicado à frente) usa-se o inteiroR.layout.activity_tela1, como demonstrado no código da classe Tela1.java anteriormente.

Você até pode a abrir o arquivo R.java:

A pasta Android 4.2 (o nome pode variar de acordo com a versão do Android) contém a referência da biblioteca do Android:

Essa biblioteca contém todos os pacotes e respectivas classes do Android.

A pasta Android Dependencies é uma pasta virtual do Eclipse, que lista das dependências do projeto. As dependências são os arquivos.jar adicionados a ele:

O arquivo android-support-v4.jar contém bibliotecas de apoio, permitindo referenciar classes não mais suportadas pelo Android, mas que podem ser utilizadas em uma versão mais antiga.

Na pasta assets podem ser adicionados os recursos extras do projeto. Eles não são gerenciados automaticamente pelo plugin Android, sendo necessário fornecer um nome e um caminho válidos para todos os recursos que forem adicionados.

No momento ela não possui nenhum recurso:

Você aprenderá a gerenciar os recursos dessa pasta nos próximos cursos.

Na pasta bin é adicionada a saída do projeto, ou seja, os arquivos compilados que serão utilizados para gerar a aplicação:

Executando o projetoPara executar o projeto, no Package Explorer, clique com o botão direito do mouse sobre o projeto e selecione a opção 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 início 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 é necessário desbloquear o emulador para exibir a aplicação.

Utilizando o mouse, clique no cadeado:

E o arraste até a lateral:

A aplicação será exibida:

Obs: Não feche o emulador (caso contrário, você terá que esperar o emulador carregar quando for executar o projeto novamente).

Mesmo você não 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 são apresentadas em vermelho. Quando houver um erro, você poderá verificar a causa, consultando essa aba.

Processo de execução do projetoAo 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 método onCreate:

protected void onCreate(Bundle savedInstanceState) {Ele será executado automaticamente assim que a classe for carregada para a memória.

Dentro do método onCreate é chamado o método onCreate da classe-pai (no caso a classe Activity):

super.onCreate(savedInstanceState);

A palavra-chave super é utilizada para referenciar o método da classe-pai.

Logo em seguida, é executado o método setContentView:

setContentView(R.layout.activity_tela1);

Será esse método que, efetivamente, irá criar a apresentação na tela. Observe que foi passado como parâmetro o R.layout.activity_tela1, que nada mais é do que a referência ao arquivo acitivity_tela1.xml, ou seja, a tela:

Observe o código-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:

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

O valor @string/hello_world se refere à informação de outro arquivo de recursos, que no caso é o arquivo string.xml:

Repare na linha:

Adicionando novos recursosComo já explicado, os recursos podem ser imagens ou textos utilizados pela aplicação. No momento serão adicionados novos textos no projeto.

Os textos serão incluídos no arquivo strings.xml da pasta res/values:

Que no momento só possui duas informações:

<resources>    <string name="app_name">Primeiro Exemplo</string>    <string name="hello_world">Olá Mundo!</string>    <string name="menu_settings">Configurações</string></resources>Existem duas formas de adicionar recursos nesse arquivo: pela forma gráfica ou pelo código-fonte.

Adicionando recursos diretamente no xmlPara 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 maiúscula de minúscula e as tags devem estar corretamente formatadas. Para evitar erros de digitação você deve utilizar ao máximo a complementação de código. Por exemplo:

Antes da tag </resources> digite apenas o símbolo de menor (<):

Uma lista suspensa deverá aparecer. Caso não apareça, pressione CTRL + barra de espaço para exibi-la:

Ela exibe os recursos disponíveis que podem ser adicionados no arquivo. Como esse é um arquivo de recursos string, só essa opção estará disponível. Selecione a opção string e comece a digitar a propriedade name, mas digite apenas a letra n e pressione Ctrl+ barra de espaço para exibir as opções disponíveis:

Agora você pode criar o recurso com possibilidades mínimas de erro. Desta forma, crie um recurso chamado aluno, conforme o código abaixo:

<resources>    <string name="app_name">Primeiro Exemplo</string>    <string name="hello_world">Olá Mundo!</string>    <string name="menu_settings">Configurações</string>  <string name="aluno">Carlos Santos Silva</string></resources>Na parte gráfica o processo é mais simples e seguro.

Adicionando recurso no modo designMude para o modo design, selecionando a aba Resources no rodapé do arquivo:

A seguinte tela será exibida:

Clique no botão Add...; a caixa de diálogo a seguir será exibida:

Selecione a opção 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 básico, 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, além de mais produtivo, oferece menos chances de gerar erros de digitação.

O arquivo conterá os seguintes recursos:

<resources>    <string name="app_name">Primeiro Exemplo</string>    <string name="hello_world">Olá Mundo!</string>    <string name="menu_settings">Configurações</string>  <string name="aluno">Carlos Santos Silva</string>  <string name="curso">Android Básico</string></resources>

Adicionando Widgets à aplicaçãoUm widget é um objeto visual utilizado para a criação da interface da aplicação. O Android disponibiliza uma série de widgets prontos como: botões, caixas de texto, caixas de verificação etc.

O arquivo activity_tela1.xml dentro da pasta res/layout:

É o arquivo responsável pela interface do usuário. Dê um duplo clique sobre ele para exibir a seguinte tela:

Observe, na imagem acima à esquerda, a Pallete que contém uma aba com vários widgets que podem ser adicionados à tela.

TextViewPara adicioná-los é só arrastar o widget da Pallete para a tela. Faça 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 incluído no arquivo strings.xml, basta clicar com o botão direito do mouse sobre o TextView e selecionar a opção 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 botão OK:

Observe que o conteúdo do recurso denominado aluno (Carlos Santos Silva) já aparece na tela.

Mude para o código-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_width="wrap_content"        android:layout_height="wrap_content"        android:layout_centerHorizontal="true"        android:layout_centerVertical="true"        android:text="@string/hello_world" />    <TextView        android:id="@+id/textView1"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        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 diferenças: os atributos estão na mesma linha, o que não interfere em nada; e já foi adicionado o atributo android:id, que é utilizado para identificar o widget via programação (como será explicado à frente).

Você pode adicionar e alterar widgets diretamente no arquivo, mas a forma gráfica é a mais recomendável para se trabalhar com widgets.

Executando o projeto AndroidExecute o projeto para visualizar a alteração:

Repita o procedimento (adicione um TextView e informe o recurso de texto) para exibir o nome do curso:

Trabalhando com eventosPrimeiramente, abra o arquivos de recursos (strings.xml) e adicione os recursos msg, texto_nome, botao_proximo, botao_ok e resposta, conforme o código abaixo:

<resources>    <string name="app_name">Primeiro Exemplo</string>    <string name="hello_world">Olá Mundo!</string>    <string name="menu_settings">Configurações</string>  <string name="aluno">Carlos Santos Silva</string>  <string name="curso">Android Básico</string>  <string name="msg">Digite seu nome abaixo</string>  <string name="texto_nome"></string>  <string name="botao_proximo">Próxima 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 três 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: inserção 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 opção 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 serão referenciados no código, é necessário definir os seus IDs.

Para definir o ID de um widget, clique com o botão direito do mouse sobre o widget e selecione a opção Edit ID...:

A caixa de diálogo 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 são posicionados em relação ao outro widget da tela. Essa relação é verificada de acordo com o ID do widget. Então, ao modificá-lo, o widget pode perder a referência e modificar a sua posição (layouts serão explicados à frente).

Repita o mesmo processo para Button e para os dois TextView, onde os widgets terão, respectivamente, os Ids: buttonProximo,textViewMensagem e textViewResposta.

O código-fonte do layout será semelhante ao código abaixo:

<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:id="@+id/textViewMensagem"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignParentLeft="true"        android:layout_alignParentTop="true"        android:layout_marginLeft="19dp"        android:layout_marginTop="14dp"        android:text="@string/msg" />    <EditText        android:id="@+id/editTextNome"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignLeft="@+id/textViewMensagem"        android:layout_below="@+id/textViewMensagem"        android:layout_marginTop="18dp"        android:ems="10"        android:inputType="textPersonName"        android:text="@string/texto_nome" >        <requestFocus />    </EditText>    <Button        android:id="@+id/buttonProximo"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignLeft="@+id/editTextNome"        android:layout_below="@+id/editTextNome"        android:layout_marginTop="18dp"        android:text="@string/botao_ok" />    <TextView        android:id="@+id/textViewResposta"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignLeft="@+id/buttonProximo"        android:layout_below="@+id/buttonProximo"        android:layout_marginTop="20dp"        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;public class Tela1 extends Activity {    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_tela1);    }    @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 EventosDe forma similar ao swing e awt (do Java), para adicionar um evento à classe é necessário implementar uma ou mais interfaces, de acordo com o evento desejado.

Para implementar o evento clique do botão, utilize a interface OnClickListener do pacote android.view.View.

Obs: Para conhecer mais sobre esta interface acesse o site da documentação do Android no link:http://developer.android.com/reference/android/view/View.OnClickListener.html

No código da classe digite implements e On e pressione Ctrl + espaço. Para a complementação de código serão mostradas as opções disponíveis:

Selecione a opção desejada que, no caso deste exemplo, é a interface OnClickLister do pacote android.view.View:

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 lâmpada com o x vermelho, na frente da linha:

Observe, pela mensagem de erro, que está faltando a implementação do método onClick(). Como a documentação do Android é estruturada da mesma forma que a documentação do Java, o Eclipse já fornece possíveis soluções para o erro.

O que se quer é implementar o método. Então, selecione a primeira opção sugerida pelo Eclipse (Add unimplemented methods) e o método será criado:

public class Tela1 extends Activity implements OnClickListener {    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_tela1);    }    @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;    }  @Override  public void onClick(View v) {    // TODO Auto-generated method stub  }}Agora você deverá associar esse evento ao botão.

Associando o evento ao botãoPara associar o evento ao botão, primeiro é preciso identificar o botão com o método findViewById (esse método sempre será utilizado para identificar os widgets do projeto). O método recebe como parâmetro a constante referente ao widget que se quer localizar, conforme mostra o seguinte código:

Button btn = (Button) findViewById(R.id.buttonProximo);

Note que, além de identificar o widget, está convertendo o resultado do método para o tipo Button e atribuindo a uma variável também tipo Button. Lembre-se de importar a classe Button:

import android.widget.Button;

Obs: O método findViewById retorna uma View; para utilizar os eventos e método do widget corretamente é preciso converter o resultado para o tipo do widget com que se irá trabalhar.

Agora você já tem a variável que representa o widget para associá-lo ao evento: o método setOnClickListener, passando como parâmetro a palavra-chave this (que representa a classe atual):

btn.setOnClickListener(this);

Esse código será adicionado ao método OnCreate da seguinte forma:

protected void onCreate(Bundle savedInstanceState) {    super.onCreate(savedInstanceState);    setContentView(R.layout.activity_tela1);    Button btn = (Button) findViewById(R.id.buttonProximo);    btn.setOnClickListener(this);}Falta apenas adicionar o código do método onClick, que irá obter o conteúdo da caixa de texto (o EditText) e atribuir o resultado a uma variável, que será atribuída novamente ao TextView resultado. Conforme mostra o código abaixo:

public void onClick(View v) {  // TODO Auto-generated method stub  TextView tvResultado = (TextView) findViewById(R.id.textViewResposta);  EditText txtNome = (EditText) findViewById(R.id.editTextNome);  String msg = "Nome: " + txtNome.getText().toString();  tvResultado.setText(msg);}Também importe as duas classes dos widgets:

import android.widget.EditText;

import android.widget.TextView;

O código da classe ficará da seguinte forma:

package br.com.treinaweb.parte1;import android.os.Bundle;import android.app.Activity;import android.view.Menu;import android.view.View;import android.view.View.OnClickListener;import android.widget.Button;import android.widget.EditText;import android.widget.TextView;public class Tela1 extends Activity implements OnClickListener {    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_tela1);        Button btn = (Button) findViewById(R.id.buttonProximo);        btn.setOnClickListener(this);    }    @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;    }  @Override  public void onClick(View v) {    // TODO Auto-generated method stub    TextView tvResultado = (TextView) findViewById(R.id.textViewResposta);

    EditText txtNome = (EditText) findViewById(R.id.editTextNome);    String msg = "Nome: " + txtNome.getText().toString();    tvResultado.setText(msg);  }}Salve o arquivo e execute o projeto:

Digite seu nome e clique no botão OK para exibir o conteúdo da caixa de texto no TextView.

Criando uma nova telaPara 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 opção (caso você já possua os recursos de texto), as demais devem ser sempre executadas na ordem acima; caso contrário, o projeto não reconhecerá a nova Activity.

Siga estas etapas:

1 – Criando os recursosAdicione no arquivo strings.xml os recursos titulo e ensino, conforme indicado no código a seguir:

<resources>    <string name="app_name">Primeiro Exemplo</string>    <string name="hello_world">Olá Mundo!</string>    <string name="menu_settings">Configurações</string>  <string name="aluno">Carlos Santos Silva</string>  <string name="curso">Android Básico</string>  <string name="msg">Digite seu nome abaixo</string>  <string name="texto_nome"></string>  <string name="botao_proximo">Próxima Tela</string>  <string name="botao_ok">OK</string>  <string name="resposta">Resposta:</string>  <string name="ensino">Treinaweb Cursos</string>  <string name="titulo">Informações do curso</string></resources>

2 – Criando um novo arquivo de layoutNo Package explorer, clique com o botão direito do mouse sobre a pasta res/layout e selecione a opção 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 opções padrão, 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, é possível modificar essa orientação 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 com os recursos: titulo, curso e ensino, conforme a imagem abaixo:

Para finalizar essa etapa, salve seu arquivo (Ctrl+S).

3 – Criando a classe JavaComo explicado anteriormente, para criar uma tela no Android é necessário 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 botão direito do mouse sobre o pacote br.com.treinaweb.parte1, da pasta src, e selecione a opção New > Class, conforme mostra a imagem a seguir:

A caixa de diálogo New Java Class será exibida:

Para definir que a classe irá estender a classe Activity, clique no botão Browse, na opção Superclass, para que a janela Superclass Selection seja exibida:

Em Choose a type digite Activity para exibir, em Matching items, as seguintes opções:

Selecione a primeira opção (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 método onCreate, conforme indicado no código abaixo:

package br.com.treinaweb.parte1;

import android.app.Activity;import android.os.Bundle;public class Tela2 extends Activity {  public void onCreate(Bundle savedInstanceState){    super.onCreate(savedInstanceState);    setContentView(R.layout.activity_tela2);  }}Observe que o novo layout está sendo referenciado:

4 – Exibindo a nova telaPara exibir a nova tela, primeiro é preciso mapear o activity no arquivo AndroidManifest.xml:

Mude para o código-fonte (selecione a aba AndroidManifest.xml):

Após a tag </activity> adicione a activity, conforme o código abaixo:

<activity    android:name="br.com.treinaweb.parte1.Tela2"    android:label="@string/app_name"></activity>Observe, no código acima, que não foi necessário declarar uma Intent (intenção) para a Tela2. No primeiro activity a Intent foi adicionada automaticamente, sendo necessária para especificar a classe que será executada ao iniciar a aplicação (semelhante ao método 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:name="br.com.treinaweb.parte1.Tela1"

            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            android:name="br.com.treinaweb.parte1.Tela2"            android:label="@string/app_name">        </activity>    </application></manifest>Obs: Para alterar o activity inicial da aplicação basta modificar a linha abaixo, inserindo o nome do novo activity:

<activity    android:name="br.com.treinaweb.parte1.Tela1"Ou adicionar no intent filter do activity a action MAIN:

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

Lembrando que apenas uma activity pode ter a action MAIN em uma aplicação.

Executando o projeto para visualizar a nova telaExecute o projeto:

Clique no botão para a segunda tela ser apresentada:

Voltando para a tela anteriorPara retornar à tela anterior, é necessário adicionar um botão na segunda tela (activity_tela2.xml) e programá-lo para retornar, conforme mostra a imagem a seguir:

O código-fonte da tela será o seguinte:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"    android:layout_width="match_parent"    android:layout_height="match_parent"    android:orientation="vertical" >    <TextView        android:id="@+id/textView1"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:text="@string/titulo" />    <TextView        android:id="@+id/textView2"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:text="@string/curso" />    <TextView        android:id="@+id/textView3"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:text="@string/ensino" />

    <Button        android:id="@+id/buttonVoltar"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:text="@string/botao_voltar" /></LinearLayout>Já no activity Tela2, implemente a interface OnClickListener e o método OnClick, atribuindo-o ao botão recém-aplicado no arquivo de interface, conforme indicado no código abaixo:

package br.com.treinaweb.parte1;import android.app.Activity;import android.os.Bundle;import android.view.View;import android.view.View.OnClickListener;public class Tela2 extends Activity implements OnClickListener {  public void onCreate(Bundle savedInstanceState){    super.onCreate(savedInstanceState);    setContentView(R.layout.activity_tela2);    Button btnVoltar = (Button) findViewById(R.id.buttonVoltar);    btnVoltar.setOnClickListener(this);  }  @Override  public void onClick(View arg0) {    // TODO Auto-generated method stub    finish();  }}Note que foi usado apenas o método finish() para encerrar a activity atual (no caso, Tela2) e voltar para a activity anterior (Tela1).

Executando o projetoExecute a aplicação e clique no botão OK para exibir a segunda activity:

Clique no botão Voltar para retornar à primeira activity:

Para entender os eventos que ocorrem com cada activity (tela) é necessário conhecer o ciclo de vida e os eventos das mesmas.

Ciclo de vida das ActivitiesAs activities são armazenadas na memória como se fossem uma pilha (stack) de telas, uma em cima da outra, ficando visível para o usuário 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 específico:

Onde:

onCreate(): Método chamado quando a atividade é criada. Nele são criadas as views e obtidos os dados que irão carregar as listas da tela. onStart(): Método chamado quando a atividade torna-se visível para o usuário. onResume(): Esse método ocorre quando a atividade está no topo da pilha e o usuário já pode interagir com a tela. onPause(): Chamado quando a atividade está começando a ser substituída ou a aplicação está começando a se encerrar. Geralmente é utilizado para gravar as informações que ainda não foram salvas. onRestart(): Esse método ocorre quando o atividade é pausada e chamada novamente.

onStop(): Esse método ocorre quando a atividade não estiver sendo executada e saiu do topo da pilha de atividades. onDestroy(): Chamado quando a atividade é finalizada; pode ser por código ou quando o sistema precisa liberar recursos.

Entendendo o ciclo de vidaAssim que uma atividade é iniciada é colocada no topo da pilha de atividades e se torna uma atividade em execução. Caso exista alguma atividade anterior, ela ficará em uma posição logo abaixo na pilha e só passará para o estado de execução quando a atividade acima for finalizada.

São 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 mantém todas as informações de estado, porém sem interagir com o usuário. Pode ser finalizada se o sistema operacional necessitar de memória (recursos). Interrompida: Caso da atividade que não está sendo utilizada, mas que mantém as suas informações de estado, porém é finalizada para a liberação de memória, perdendo suas informações. Finalizada: Quando a atividade é finalizada pelo sistema operacional ou por uma implementação 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 métodos onDestroy ou onStop, como demonstra o diagrama acima.

Basicamente podem ocorrer três ciclos com uma atividade:

Ciclo completo: inicia-se no método onCreate() e a atividade realiza toda a configuração, passando de um estado para o outro e terminando no método onDestroy(), quando todos os recursos utilizados pela atividade são liberados. Ciclo de vida visível: inicia-se no método onStart() e termina no método onStop(). É o ciclo onde a atividade está disponível e visível para o usuário, mesmo que ele não esteja interagindo com a tela. Quando o usuário não visualizar mais a atividade, o método onStop() é chamado; ou então, para tornar a atividade visível, chama-se o método onStart(). Primeiro ciclo da atividade: ocorre entre os métodos onResume() e onPause(). Este é o período em que a atividade está visível e interagindo com o usuário, no topo da pilha de atividades. O código utilizado nesse período não pode ser pesado, pela iminente possibilidade de troca dos estados onPause() e onResume().A movimentação de uma atividade para outra ocorre através da Intent, requisições disparadas pelas atividades para descrever o que pode ser feito em caso de acionamento.

LayoutsLayouts são classes que formam a infraestrutura da tela (view), facilitando a distribuição dos vários widgets nela.

No exemplo, foram usados dois tipos de layout para construir as telas. O primeiro é o RelativeLayout do arquivo activity_tela1.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:id="@+id/textViewMensagem"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignParentLeft="true"        android:layout_alignParentTop="true"        android:layout_marginLeft="19dp"        android:layout_marginTop="14dp"        android:text="@string/msg" />    <EditText        android:id="@+id/editTextNome"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignLeft="@+id/textViewMensagem"        android:layout_below="@+id/textViewMensagem"        android:layout_marginTop="18dp"        android:ems="10"        android:inputType="textPersonName"        android:text="@string/texto_nome" >        <requestFocus />    </EditText>    <Button        android:id="@+id/buttonProximo"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignLeft="@+id/editTextNome"        android:layout_below="@+id/editTextNome"        android:layout_marginTop="18dp"        android:text="@string/botao_ok" />    <TextView        android:id="@+id/textViewResposta"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignLeft="@+id/buttonProximo"        android:layout_below="@+id/buttonProximo"        android:layout_marginTop="20dp"        android:text="@string/resposta" /></RelativeLayout>Note o início do arquivo:

<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" >É nele que se informa o tipo de layout do arquivo. Esse layout será explicado à frente.

O segundo é o LinearLayout de activity_tela2.xml:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"    android:layout_width="match_parent"    android:layout_height="match_parent"    android:orientation="vertical" >    <TextView        android:id="@+id/textView1"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:text="@string/titulo" />    <TextView        android:id="@+id/textView2"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:text="@string/curso" />    <TextView        android:id="@+id/textView3"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:text="@string/ensino" />    <TextView        android:id="@+id/textViewAluno"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:text="@string/aluno" />    <Button        android:id="@+id/buttonVoltar"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:text="@string/botao_voltar" /></LinearLayout>

Note que foi usado o LinearLayout:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"    android:layout_width="match_parent"    android:layout_height="match_parent"    android:orientation="vertical" >O LinearLayout posiciona os objetos na sequência, um após o outro, na horizontal ou vertical, dependendo do atributo orientation. No código acima eles estão organizados na posição vertical.

O Android disponibiliza uma série de opções de layouts, sendo os principais:

LinearLayout

TableLayout RelativeLayout AbsoluteLayout FrameLayoutA primeira opção é a mais simples, usada na activity_tela2.xml, como mostrado no exemplo acima. Os demais serão demonstrados a seguir.

LayoutsLayouts são classes que formam a infraestrutura da tela (view), facilitando a distribuição dos vários widgets nela.

No exemplo, foram usados dois tipos de layout para construir as telas. O primeiro é o RelativeLayout do arquivo activity_tela1.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:id="@+id/textViewMensagem"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignParentLeft="true"        android:layout_alignParentTop="true"        android:layout_marginLeft="19dp"        android:layout_marginTop="14dp"        android:text="@string/msg" />    <EditText        android:id="@+id/editTextNome"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignLeft="@+id/textViewMensagem"        android:layout_below="@+id/textViewMensagem"        android:layout_marginTop="18dp"        android:ems="10"        android:inputType="textPersonName"        android:text="@string/texto_nome" >        <requestFocus />    </EditText>    <Button        android:id="@+id/buttonProximo"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignLeft="@+id/editTextNome"        android:layout_below="@+id/editTextNome"        android:layout_marginTop="18dp"        android:text="@string/botao_ok" />    <TextView        android:id="@+id/textViewResposta"

        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignLeft="@+id/buttonProximo"        android:layout_below="@+id/buttonProximo"        android:layout_marginTop="20dp"        android:text="@string/resposta" /></RelativeLayout>Note o início do arquivo:

<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" >É nele que se informa o tipo de layout do arquivo. Esse layout será explicado à frente.

O segundo é o LinearLayout de activity_tela2.xml:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"    android:layout_width="match_parent"    android:layout_height="match_parent"    android:orientation="vertical" >    <TextView        android:id="@+id/textView1"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:text="@string/titulo" />    <TextView        android:id="@+id/textView2"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:text="@string/curso" />    <TextView        android:id="@+id/textView3"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:text="@string/ensino" />    <TextView        android:id="@+id/textViewAluno"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:text="@string/aluno" />    <Button        android:id="@+id/buttonVoltar"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:text="@string/botao_voltar" /></LinearLayout>Note que foi usado o LinearLayout:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"    android:layout_width="match_parent"    android:layout_height="match_parent"    android:orientation="vertical" >

O LinearLayout posiciona os objetos na sequência, um após o outro, na horizontal ou vertical, dependendo do atributo orientation. No código acima eles estão organizados na posição vertical.

O Android disponibiliza uma série de opções de layouts, sendo os principais:

LinearLayout TableLayout RelativeLayout AbsoluteLayout FrameLayoutA primeira opção é a mais simples, usada na activity_tela2.xml, como mostrado no exemplo acima. Os demais serão demonstrados a seguir.

TableLayoutO TableLayout permite trabalhar com linhas como se fosse uma tabela do HTML (mas bem mais limitada) e as colunas são criadas automaticamente quando algum widget é adicionado.

Faça 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 gráfico e clique na aba Graphical Layout:

Exemplo de TableLayoutPara 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 botão, conforme indicado no código-fonte abaixo:

<TableLayout xmlns:android="http://schemas.android.com/apk/res/android"    android:layout_width="match_parent"    android:layout_height="match_parent" >    <TableRow        android:id="@+id/tableRow1"        android:layout_width="wrap_content"        android:layout_height="wrap_content" >        <TextView            android:id="@+id/textViewNome"            android:layout_width="60dp"            android:layout_height="40dp"            android:text="@string/nome" />        <EditText            android:id="@+id/editTextNome"            android:layout_width="250dp"            android:layout_height="40dp"            android:ems="10"            android:inputType="textPersonName" >            <requestFocus />        </EditText>    </TableRow>    <TableRow        android:id="@+id/tableRow2"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:gravity="center|" >        <Button            android:id="@+id/buttonOk"            android:layout_width="60dp"            android:layout_height="40dp"            android:text="@string/botao_ok" />    </TableRow></TableLayout>Note que, para alinhamento dos objetos dentro da coluna, foi usado o atributo gravity que possui diversas opções que aparecem ao se utilizar as teclas CTRL + Espaço, forçando a complementação do código:

Unidades de medida utilizadas no AndroidObserve também que os widgets estão sendo dimensionados, usando a unidade dp. O Android suporta as seguintes unidades de medida:

px (pixel) ou pontos na tela. mm (millimeters) ou milímetros. 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: Sinônimo de dp (utilize dp no lugar de dip) sp (scale-independent pixels) é similar à dp mas leva em consideração a fonte do texto.Além do fill_parent (que ocupa todo o espaço onde o objeto está contido) e da wrap_content (onde o objeto se ajusta ao seu conteúdo).

Para usar uma unidade de medida basta informar seu valor seguido da unidade. A recomendação é utilizar as meditas relativas, como spe dp, por facilitar a quem trabalha com múltiplas resoluções.

Criando a ActivityVoltando ao exemplo de TableLayout, crie uma classe Java que irá estender a classe Activity do Android, conforme mostra o código a seguir:

package br.com.treinaweb.parte1;import android.app.Activity;import android.os.Bundle;public class Tela3 extends Activity {   @Override

   protected void onCreate(Bundle savedInstanceState) {     super.onCreate(savedInstanceState);     setContentView(R.layout.activity_tela3);   }}Para definir esta activity como tela inicial da aplicação, você deverá modificar o arquivo Android.Manifest. Nele, com o intent-filter da activity Tela1, crie uma tag <activity> para a nova activity Tela3. Faça da seguinte forma:

<activity    android:name="br.com.treinaweb.parte1.Tela3"    android:label="@string/app_name" >    <intent-filter>        <action android:name="android.intent.action.MAIN" />        <category android:name="android.intent.category.LAUNCHER" />    </intent-filter></activity>Remova o intent-filter da activity Tela1 para não gerar erro. O arquivo Android.Manifest 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:name="br.com.treinaweb.parte1.Tela1"            android:label="@string/app_name" >        </activity>        <activity            android:name="br.com.treinaweb.parte1.Tela2"            android:label="@string/app_name">        </activity>        <activity            android:name="br.com.treinaweb.parte1.Tela3"            android:label="@string/app_name" >            <intent-filter>                <action android:name="android.intent.action.MAIN" />                <category android:name="android.intent.category.LAUNCHER" />            </intent-filter>        </activity>    </application></manifest>Ao executar a aplicação, o layout activity_tela3.xml será apresentado:

Resolução do EmuladorPara visualizar como os widgets e a aplicação se comportam em outras resoluções, basta alterar as configurações do próprio emulador.

Abra o Android Virtual Dervice Manager pelo menu iniciar, ou na opção Windows > Android Virtual Dervice Manager do Eclipse:

O Android Virtual Dervice Manager será aberto:

Selecione o seu emulador e clique no botão Edit para ser exibida a seguinte caixa de diálogo:

Na opção Device você pode escolher outra opção de Device, que possua outra resolução:

Clique no botão Ok para salvar as alterações.

Feche o emulador, caso ele esteja aberto, e execute novamente o projeto para visualizá-lo em nova resolução:

Teste as demais opções disponíveis.

RelativeLayoutEsse tipo de layout foi mostrado no primeiro exemplo do curso. Ele é baseado em posições relativas de um widget em relação a outro pré-existente. Para esse tipo de layout o atributo ID do widget é obrigatório.

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 código abaixo:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"    android:layout_width="match_parent"    android:layout_height="match_parent" >        <Button            android:id="@+id/buttonOk"            android:layout_width="60dp"            android:layout_height="40dp"            android:layout_alignLeft="@+id/editTextNome"            android:layout_below="@+id/textViewNome"            android:text="@string/botao_ok" />        <TextView            android:id="@+id/textViewNome"            android:layout_width="60dp"            android:layout_height="40dp"            android:layout_alignBaseline="@+id/editTextNome"            android:layout_alignBottom="@+id/editTextNome"            android:layout_alignParentLeft="true"            android:layout_marginLeft="15dp"            android:text="@string/nome" />        <EditText            android:id="@+id/editTextNome"            android:layout_width="250dp"            android:layout_height="40dp"            android:layout_alignParentRight="true"            android:layout_alignParentTop="true"            android:layout_marginRight="15dp"            android:ems="10"

            android:inputType="textPersonName" /></RelativeLayout>Observe a linha:

android:layout_alignLeft="@+id/editTextNome"

Ela indica que o widget deve se posicionar à esquerda do widget cujo ID é editTextNome.

Você pode conhecer todos os parâmetros na documentação online:http://developer.android.com/reference/android/widget/RelativeLayout.LayoutParams.html

Para este layout não é necessário criar nova Activity, bastando alterar a activity Tela3:

public class Tela3 extends Activity {   @Override   protected void onCreate(Bundle savedInstanceState) {     super.onCreate(savedInstanceState);     setContentView(R.layout.relative_activity_tela3);   }}Note a linha:

setContentView(R.layout.relative_activity_tela3);

Nela é definido que a activity irá exibir o layout recém-criado. Lembrando que se você criou um arquivo de layout com outro nome, ele deve ser informado nessa linha:

Ao executar a aplicação ele será exibido:

FrameLayoutO FrameLayout é um espaço reservado na tela que você pode utilizar para exibir outro tipo de conteúdo, como no exemplo abaixo:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"    android:layout_width="match_parent"    android:layout_height="match_parent" >        <Button            android:id="@+id/buttonOk"            android:layout_width="60dp"            android:layout_height="40dp"            android:layout_alignLeft="@+id/editTextNome"            android:layout_below="@+id/textViewNome"            android:text="@string/botao_ok" />        <TextView            android:id="@+id/textViewNome"            android:layout_width="60dp"            android:layout_height="40dp"            android:layout_alignBaseline="@+id/editTextNome"            android:layout_alignBottom="@+id/editTextNome"            android:layout_alignParentLeft="true"            android:layout_marginLeft="15dp"            android:text="@string/nome" />        <EditText            android:id="@+id/editTextNome"            android:layout_width="250dp"            android:layout_height="40dp"            android:layout_alignParentRight="true"            android:layout_alignParentTop="true"            android:layout_marginRight="15dp"            android:ems="10"            android:inputType="textPersonName" />        <FrameLayout            android:layout_width="wrap_content"            android:layout_height="wrap_content"            android:layout_below="@+id/buttonOk"            android:layout_marginTop="29dp"            android:layout_toRightOf="@+id/buttonOk" >            <ImageView                android:id="@+id/imageView1"                android:layout_width="wrap_content"                android:layout_height="wrap_content"                android:src="@drawable/ic_launcher"                android:contentDescription="@string/imagem" />        </FrameLayout></RelativeLayout>No código acima, o exemplo do RelativeLayout foi modificado, pois foi incluído um FrameLayout com uma imagem. Ao executar o projeto, a tela será exibida com a imagem:

Vários widgets podem ser adicionados em um FrameLayout, mas cada um ficará sobre o outro como em uma pilha.

ScrollViewO ScrollView é um tipo especial de layout que permite aos usuários arrastar a tela para visualizar todos os pontos do layout. O ScrollViewpode conter apenas um View ou ViewGroup, que normalmente é um LinearLayout.

Faça este exemplo: crie um novo arquivo de layout, baseado no template ScrollView, e adicione um LinearLayout e alguns Button, conforme mostra o código abaixo:

<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"    android:layout_width="match_parent"    android:layout_height="match_parent" >    <LinearLayout        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:orientation="vertical" >        <Button            android:id="@+id/button1"            android:layout_width="300dp"            android:layout_height="200dp"            android:text="@string/botao_ok" />        <Button            android:id="@+id/button2"            android:layout_width="300dp"            android:layout_height="200dp"            android:text="@string/botao_ok" />        <Button            android:id="@+id/button3"            android:layout_width="300dp"            android:layout_height="200dp"

            android:text="@string/botao_ok" />    </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 usuários arrastar a tela para visualizar os widgets localizados na parte inferior.

Obs: Não é recomendável utilizar o ListView (explicado à frente) com o ScrollView.

Usando Widgets de Seleção

Em alguns momentos é necessário restringir o tipo de dado que o usuário pode digitar, bem como definir as opções que ele possa ter, e apenas com o EditText não se tem muitas opções.

Nesses casos você deve utilizar os widgets de seleção (explicados neste tópico) como ListView, Radio e CheckBox.

ListViewPara exibir listas no Android utiliza-se o widget ListView. Para utilizá-lo, basta adicionar um ListView em um arquivo de layout e utilizar o método setAdapter para carregar os itens da lista, sendo que os itens podem ser criados em um arquivo de recursos – ou via código.

Faça este exemplo: crie um novo arquivo de layout e adicione dois TextViews e um ListView, conforme mostra o código abaixo:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"    android:layout_width="match_parent"    android:layout_height="match_parent" >    <TextView        android:id="@+id/textViewRotulo"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignParentLeft="true"        android:layout_alignParentTop="true"        android:layout_marginLeft="10dp"        android:layout_marginTop="10dp"        android:text="@string/rotolo" />    <ListView        android:id="@+id/listViewCursos"        android:layout_width="match_parent"        android:layout_height="wrap_content"        android:layout_alignLeft="@+id/textViewRotulo"        android:layout_below="@+id/textViewRotulo" >    </ListView>    <TextView        android:id="@+id/textViewResposta"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignLeft="@+id/listViewCursos"        android:layout_alignParentBottom="true"        android:text="@string/resposta" /></RelativeLayout>Se você mudar para o modo de designer notará que o ListView ocupa toda a tela:

Isso acontece porque ele possui apenas informações de exemplo para dar noção de como a tela será apresentada no layout.

Exemplo de ListViewA informação 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="app_name">Primeiro Exemplo</string>    <string name="hello_world">Olá Mundo!</string>    <string name="menu_settings">Configurações</string>  <string name="aluno">Carlos Santos Silva</string>  <string name="curso">Android Básico</string>  <string name="msg">Digite seu nome abaixo</string>  <string name="texto_nome"></string>  <string name="botao_proximo">Próxima Tela</string>  <string name="botao_ok">OK</string>  <string name="resposta">Resposta:</string>  <string name="ensino">Treinaweb Cursos</string>  <string name="titulo">Informações do curso</string>  <string name="botao_voltar">Voltar</string>  <string name="nome">Nome:</string>  <string name="imagem">Ícone aplicação</string>  <string name="rotolo">Selecione uma opção:</string>  <string-array name="cursos">

      <item>Curso Android básico</item>      <item>Curso Java básico</item>      <item>Curso C# básico</item>      <item>Curso VB.NET básico</item>  </string-array></resources>Para carregar o ListView é preciso modificar a activity Tela3, adicionando o código abaixo:

import android.app.Activity;import android.os.Bundle;import android.widget.ArrayAdapter;import android.widget.ListView;public class Tela3 extends Activity {   @Override   protected void onCreate(Bundle savedInstanceState) {     super.onCreate(savedInstanceState);     setContentView(R.layout.activity_tela4);     String[] cursos = getResources().getStringArray(R.array.cursos);     ArrayAdapter<String> aAdapter = new ArrayAdapter<String>(this, android.R.layout.simple_gallery_item, cursos);     ListView list = (ListView) findViewById(R.id.listViewCursos);     list.setAdapter(aAdapter);   }}Observe que o método setContentView foi modificado para carregar o arquivo de layout:

setContentView(R.layout.activity_tela4);

Depois, os dados do arquivo de recurso foram inseridos:

String[] cursos = getResources().getStringArray(R.array.cursos);

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.simple_gallery_item, cursos);

Note que a primeira instrução é this, que referencia a própria classe; o segundo parâmetro é o layout do item. Há várias opções de layout:

Depois experimente as outras opções de layout dos itens.

O último parâmetro do ArrayAdapter é o array.

Após o ArrayAdapter você deve criar uma variável que representa o ListView:

ListView list = (ListView) findViewById(R.id.listViewCursos);

Para finalizar, carregue o ArrayAdapter ao ListView, atráves do método setAdapter:

list.setAdapter(aAdapter);

Salve a activity e execute a aplicação:

Agora, para carregar as informações via código, basta criar um array para ser utilizado no ArrayAdapter:

public class Tela3 extends Activity {   @Override   protected void onCreate(Bundle savedInstanceState) {     super.onCreate(savedInstanceState);     setContentView(R.layout.activity_tela4);     //String[] cursos = getResources().getStringArray(R.array.cursos);     String[] cursos = {"Android Básico", "Java Básico", "C# Básico"};     ArrayAdapter<String> aAdapter = new ArrayAdapter<String>(this, android.R.layout.simple_gallery_item, cursos);     ListView list = (ListView) findViewById(R.id.listViewCursos);     list.setAdapter(aAdapter);   }}Note que foi comentada apenas a linha que carrega os dados do arquivo de recurso:

//String[] cursos = getResources().getStringArray(R.array.cursos);

E foi criado um novo array:

String[] cursos = {"Android Básico", "Java Básico", "C# Básico"};

Execute a aplicação:

Identificando o item selecionadoPara identificar o item selecionado, basta implementar na activity a interface onItemClickListener e o método onItemClick, e associar o evento ItemClick ao widget ListView, conforme o código abaixo:

import android.app.Activity;import android.os.Bundle;import android.view.View;import android.widget.AdapterView;import android.widget.AdapterView.OnItemClickListener;import android.widget.ArrayAdapter;import android.widget.ListView;import android.widget.TextView;

public class Tela3 extends Activity implements OnItemClickListener {   @Override   protected void onCreate(Bundle savedInstanceState) {     super.onCreate(savedInstanceState);     setContentView(R.layout.activity_tela4);     //String[] cursos = getResources().getStringArray(R.array.cursos);     String[] cursos = {"Android Básico", "Java Básico", "C# Básico"};     ArrayAdapter<String> aAdapter = new ArrayAdapter<String>(this, android.R.layout.simple_gallery_item, cursos);     ListView list = (ListView) findViewById(R.id.listViewCursos);     list.setAdapter(aAdapter);     list.setOnItemClickListener(this);   }  @Override  public void onItemClick(AdapterView<?> parent, View view, int position, long id) {    // TODO Auto-generated method stub    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:

list.setOnItemClickListener(this);

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

TextView resposta = (TextView) findViewById(R.id.textViewResposta);

String curso = ((TextView) view).getText().toString();

Repare, no código acima, que o view (parâmetro do método) foi convertido para um TextView; este view é o item selecionado do ListView.

Para finalizar, foi carregada a informação do TextView:

resposta.setText("Resposta: " + curso);

Execute o projeto e clique em um item:

CheckBoxO CheckBox é um widget que permite ao usuário selecionar quantas opções desejar. Faça este exemplo, crie o arquivo de layout abaixo:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"    android:layout_width="match_parent"    android:layout_height="match_parent" >    <TextView        android:id="@+id/textViewRotulo"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignParentLeft="true"        android:layout_alignParentTop="true"        android:layout_marginLeft="10dp"        android:layout_marginTop="10dp"        android:text="@string/rotolo" />    <CheckBox        android:id="@+id/checkBoxAndroidBasico"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignParentLeft="true"        android:layout_below="@+id/textViewRotulo"        android:text="@string/android_basico" />    <CheckBox        android:id="@+id/checkBoxJavaBasico"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignParentLeft="true"        android:layout_below="@+id/checkBoxAndroidBasico"        android:text="@string/java_basico" />    <CheckBox        android:id="@+id/checkBoxCSharpBasico"        android:layout_width="wrap_content"        android:layout_height="wrap_content"

        android:layout_alignParentLeft="true"        android:layout_below="@+id/checkBoxJavaBasico"        android:text="@string/csharp_basico" />    <Button        android:id="@+id/buttonOk"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignParentLeft="true"        android:layout_below="@+id/checkBoxCSharpBasico"        android:text="@string/botao_ok" />    <TextView        android:id="@+id/textViewResposta"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignParentLeft="true"        android:layout_below="@+id/buttonOk"        android:layout_marginTop="23dp"        android:text="@string/resposta" /></RelativeLayout>Note que, diferente do ListView, com o CheckBox é preciso adicionar quantos widgets forem necessários para apresentar as opções disponíveis.

Para exibir esse arquivo de layout você deve criar uma nova activity, denominada Tela5.java. Para verificar os CheckBoxs selecionados é preciso implementar a interface onClickListener e associar o botão ao evento onClick.

Dentro do método onClick é possível verificar os CheckBoxs selecionados através da propriedade isChecked. Se ela for true, ela está selecionada; se for false, não. Veja o código da activity abaixo:

import android.app.Activity;import android.os.Bundle;import android.view.View;import android.view.View.OnClickListener;import android.widget.Button;import android.widget.CheckBox;import android.widget.TextView;public class Tela5 extends Activity implements OnClickListener {  public void onCreate(Bundle savedInstanceState){    super.onCreate(savedInstanceState);    setContentView(R.layout.activity_tela5);    Button btnOk = (Button) findViewById(R.id.buttonOk);    btnOk.setOnClickListener(this);  }  @Override  public void onClick(View arg0) {    // TODO Auto-generated method stub    TextView resposta = (TextView) findViewById(R.id.textViewResposta);    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    android:name="br.com.treinaweb.parte1.Tela5"    android:label="@string/app_name" >    <intent-filter>        <action android:name="android.intent.action.MAIN" />        <category android:name="android.intent.category.LAUNCHER" />    </intent-filter></activity>Execute o projeto, selecione os cursos e clique no botão:

Também é possível implementar o evento click em cada um dos CheckBoxs. Nesse caso é preciso implementar o método onCkick direto no parâmetro do método setOnClickListener, conforme mostra o código abaixo:

public void onCreate(Bundle savedInstanceState){  super.onCreate(savedInstanceState);  setContentView(R.layout.activity_tela5);  final CheckBox chkAndroid = (CheckBox) findViewById(R.id.checkBoxAndroidBasico);  chkAndroid.setOnClickListener(new OnClickListener(){    @Override    public void onClick(View view) {      // TODO Auto-generated method stub

      TextView resposta = (TextView) findViewById(R.id.textViewResposta);      if(((CheckBox) view).isChecked())        resposta.setText("Curso: " + ((CheckBox) view).getText() + " selecionado!");      else        resposta.setText("Curso: " + ((CheckBox) view).getText() + " não está selecionado!");    }  });  Button btnOk = (Button) findViewById(R.id.buttonOk);  btnOk.setOnClickListener(this);}Esse código:

chkAndroid.setOnClickListener(new OnClickListener(){É uma classe anônima do Java.

Execute o projeto e clique no CheckBox:

RadioButtonO RadioButton, assim com o CheckBox, é um widget que apresenta opções. Mas permite ao usuário selecionar apenas uma opção dentro do grupo.

Por exemplo, crie um arquivo de layout, conforme o código abaixo:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"    android:layout_width="match_parent"    android:layout_height="match_parent" >    <TextView        android:id="@+id/textViewRotulo"        android:layout_width="wrap_content"

        android:layout_height="wrap_content"        android:layout_alignParentLeft="true"        android:layout_alignParentTop="true"        android:layout_marginLeft="10dp"        android:layout_marginTop="10dp"        android:text="@string/rotolo" />    <RadioGroup android:id="@+id/rdGroupCursos"            android:layout_width="wrap_content"            android:layout_height="wrap_content"            android:layout_alignParentLeft="true"            android:layout_below="@+id/textViewRotulo">    <RadioButton        android:id="@+id/radioButtonAndroidBasico"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:text="@string/android_basico" />    <RadioButton        android:id="@+id/radioButtonJavaBasico"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:text="@string/java_basico" />    <RadioButton        android:id="@+id/radioButtonCSharpBasico"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:text="@string/csharp_basico" />  </RadioGroup>    <Button        android:id="@+id/buttonOk"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignParentLeft="true"        android:layout_below="@+id/rdGroupCursos"        android:text="@string/botao_ok" />    <TextView        android:id="@+id/textViewResposta"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignParentLeft="true"        android:layout_below="@+id/buttonOk"        android:layout_marginTop="23dp"        android:text="@string/resposta" /></RelativeLayout>

Observe que, além dos RadioButtons, foi adicionado um RadioGroup de forma que os botões sejam parte de um grupo. Assim, é permitido que apenas um botão 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 código abaixo:

import android.app.Activity;import android.os.Bundle;

import android.view.View;import android.view.View.OnClickListener;import android.widget.Button;import android.widget.RadioButton;import android.widget.TextView;public class Tela6 extends Activity implements OnClickListener {  public void onCreate(Bundle savedInstanceState){    super.onCreate(savedInstanceState);    setContentView(R.layout.activity_tela6);    Button btnOk = (Button) findViewById(R.id.buttonOk);    btnOk.setOnClickListener(this);  }  @Override  public void onClick(View arg0) {    // TODO Auto-generated method stub    TextView resposta = (TextView) findViewById(R.id.textViewResposta);    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() + " ";    resposta.setText(msg);  }}Altere esta Activity para a Activity inicial do projeto e execute:

Também é possível implementar o evento onClick em cada um dos Button, como no CheckBox, conforme o código abaixo:

public void onCreate(Bundle savedInstanceState){  super.onCreate(savedInstanceState);  setContentView(R.layout.activity_tela6);  final RadioButton rbAndroid = (RadioButton) findViewById(R.id.radioButtonAndroidBasico);  rbAndroid.setOnClickListener(new OnClickListener(){    @Override    public void onClick(View view) {      // TODO Auto-generated method stub      TextView resposta = (TextView) findViewById(R.id.textViewResposta);      if(((RadioButton) view).isChecked())        resposta.setText("Curso: " + ((RadioButton) view).getText() + " selecionado!");      else        resposta.setText("Curso: " + ((RadioButton) view).getText() + " não está selecionado!");    }  });  final RadioButton rbJava = (RadioButton) findViewById(R.id.radioButtonJavaBasico);  rbJava.setOnClickListener(new OnClickListener(){    @Override    public void onClick(View view) {      // TODO Auto-generated method stub      TextView resposta = (TextView) findViewById(R.id.textViewResposta);      if(((RadioButton) view).isChecked())        resposta.setText("Curso: " + ((RadioButton) view).getText() + " selecionado!");      else        resposta.setText("Curso: " + ((RadioButton) view).getText() + " não está selecionado!");    }  });  final RadioButton rbCSharp = (RadioButton) findViewById(R.id.radioButtonCSharpBasico);  rbCSharp.setOnClickListener(new OnClickListener(){    @Override    public void onClick(View view) {      // TODO Auto-generated method stub      TextView resposta = (TextView) findViewById(R.id.textViewResposta);      if(((RadioButton) view).isChecked())        resposta.setText("Curso: " + ((RadioButton) view).getText() + " selecionado!");      else        resposta.setText("Curso: " + ((RadioButton) view).getText() + " não está selecionado!");    }  });  Button btnOk = (Button) findViewById(R.id.buttonOk);  btnOk.setOnClickListener(this);}

Execute o projeto e clique em algum botão:

SpinnerSpinner é um widget que permite ao usuário selecionar apenas uma opção em uma caixa suspensa como um ComboBox.

Faça este exemplo: Crie o arquivo de layout, conforme mostra o código abaixo:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"    android:layout_width="match_parent"    android:layout_height="match_parent" >    <TextView        android:id="@+id/textViewRotulo"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignParentLeft="true"        android:layout_alignParentTop="true"        android:layout_marginLeft="10dp"        android:layout_marginTop="10dp"        android:text="@string/rotolo" />    <Spinner android:id="@+id/spinnerCursos"            android:layout_width="wrap_content"            android:layout_height="wrap_content"            android:layout_alignParentLeft="true"            android:layout_below="@+id/textViewRotulo">  </Spinner>    <Button        android:id="@+id/buttonOk"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignParentLeft="true"

        android:layout_below="@+id/spinnerCursos"        android:text="@string/botao_ok" />    <TextView        android:id="@+id/textViewResposta"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignParentLeft="true"        android:layout_below="@+id/buttonOk"        android:layout_marginTop="23dp"        android:text="@string/resposta" /></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.

Faça este exemplo: Crie uma nova activity denominada Tela7.java, conforme mostra o código abaixo:

import android.app.Activity;import android.os.Bundle;import android.view.View;import android.view.View.OnClickListener;import android.widget.ArrayAdapter;import android.widget.Button;import android.widget.Spinner;import android.widget.TextView;public class Tela7 extends Activity implements OnClickListener {  private Spinner spnCursos;  public void onCreate(Bundle savedInstanceState){    super.onCreate(savedInstanceState);    setContentView(R.layout.activity_tela7);    String[] cursos = getResources().getStringArray(R.array.cursos);     ArrayAdapter<String> aAdapter = new ArrayAdapter<String>(this, android.R.layout.simple_gallery_item, cursos);     spnCursos = (Spinner) findViewById(R.id.spinnerCursos);     spnCursos.setAdapter(aAdapter);    Button btnOk = (Button) findViewById(R.id.buttonOk);    btnOk.setOnClickListener(this);  }  @Override  public void onClick(View v) {    // TODO Auto-generated method stub    TextView resposta = (TextView) findViewById(R.id.textViewResposta);    String msg = " Curso selecionado: ";    msg += ((TextView) spnCursos.getSelectedView()).getText().toString();    resposta.setText(msg);  }}

Note que o Spinner foi declarado fora do método onCreate para poder ser visível dentro do método onClick. Também observe que para pegar a informação do item selecionado, foi utilizada a propriedade getSelectedView(), convertida para TextView para obter o texto da opção.

Coloque essa activity como inicial e execute o projeto:

Selecione uma opção do combo:

Clique no botão OK:

Tipos de RecursosTodos os recursos do projeto ficam organizados dentro da pasta res. Eles são mapeados para binário e acessados através de classe de recursos (a classe R da pasta gen). Para evitar qualquer problema de compilação, o Android define onde cada tipo de recurso deve ser incluído, como os layouts na pasta res/layout e as strings na pasta res/values, dentro de um arquivo strings.xml.

Agora serão explicados mais alguns recursos que podem ser adicionados ao projeto.

Recurso ColorExistem várias 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 botão direito do mouse sobre a pasta res/values e selecione a opção New > Android XML File. A caixa de diálogo abaixo será exibida:

Em File, preencha colors.xml e clique em Finish para criar o arquivo:

Adicionando um recurso de corPara adicionar um recurso de cor, clique no botão Add... A seguinte caixa de diálogo 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 padrões abaixo:

#RGB #ARGB #RRGGBB #AARRGGBBNeste exemplo digite azul em Name e #0000FF em Value, conforme mostra a imagem abaixo:

Mude para o código-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 método visual ou diretamente no código-fonte. Em caso de dúvida sobre os códigos das cores, você pode utilizar a tabela: http://www.treinaweb.com.br/treinamentos/arquivos/cores.html

O arquivo de exemplo que será utilizado contém 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 incluídas nesse arquivo podem ser aplicadas a qualquer arquivo de layout. Faça este exemplo: Abra o código-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 código:

<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"    android:background="@color/prento" >    <TextView        android:id="@+id/textViewMensagem"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignParentLeft="true"        android:layout_alignParentTop="true"        android:layout_marginLeft="19dp"        android:layout_marginTop="14dp"        android:text="@string/msg"        android:textColor="@color/vermelho" />    <EditText

        android:id="@+id/editTextNome"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignLeft="@+id/textViewMensagem"        android:layout_below="@+id/textViewMensagem"        android:layout_marginTop="18dp"        android:ems="10"        android:inputType="textPersonName"        android:text="@string/texto_nome"        android:textColor="@color/vermelho" >        <requestFocus />    </EditText>    <Button        android:id="@+id/buttonProximo"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignLeft="@+id/editTextNome"        android:layout_below="@+id/editTextNome"        android:layout_marginTop="18dp"        android:text="@string/botao_ok"        android:textColor="@color/vermelho" />    <TextView        android:id="@+id/textViewResposta"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignLeft="@+id/buttonProximo"        android:layout_below="@+id/buttonProximo"        android:layout_marginTop="20dp"        android:text="@string/resposta"        android:textColor="@color/vermelho" /></RelativeLayout>O layout ficará da seguinte forma:

Recursos Gráficos

Os recursos gráficos são incluídos na pasta res/drawable e podem ser imagens (png, jpg ou gif) ou um xml que define ou faz referência a uma imagem. Neste curso básico serão 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 resolução que os dispositivos possuem, sendo que são de extra-alta densidade (xhdpi), alta densidade (hdpi), média densidade (mdpi) e baixa densidade (ldpi).

Para saber a resolução correta de cada densidade, consulte a tabela abaixo:

Obs: Como será explicado à frente, o arquivo deve possuir o mesmo nome nas três pastas ou ocorrerá um erro de compilação.

Para ajudar a organizar os ícones da aplicação, a documentação do Android sugere a seguinte nomenclatura para a nomeação dos ícones:

Na hora em que eles forem criados, organize-os de acordo com a resolução:

Dessa forma, você pode determinar facilmente onde cada arquivo será adicionado ao projeto. Para efeito de comparação, os citados acima ficaram organizados da seguinte forma na aplicação:

Ícones de exemploNo momento você não precisa se preocupar com a criação de ícones porque todos os que serão utilizados nos próximos exemplos são disponibilizados pelo SDK.

Vá no caminho ...\sdk\platforms\android-17\data\res:

Obs: Esse caminho pertence à versão android-17. Se você estiver usando outra versão, o nome dessa pasta será diferente.

Note que está disponível grande quantidade de ícones nas diversas resoluções.

Antes de copiar os ícones que serão usados nos próximos exemplos, crie dento da pasta C:\Curso\Android as pastas da imagem abaixo:

Depois copie os ícones abaixo das pastas do SDK (sdk\platforms\android-17\data\res ) para as pastas ícones\ic_menu* de acordo com a resolução:

Para adicionar as imagens ao projeto, basta arrastá-las de cada pasta para dentro das respectivas pastas de recursos do seu projeto no Eclipse:

A caixa de diálogo abaixo será exibida:

Selecione a opção Copy Files e clique no botão OK.

A pasta de recursos ficará da seguinte forma:

Repita a operação para as pastas drawable-hdpi, drawable-ldpi e drawable-mdpi de forma a ter as imagens para as 4 resoluções.

Para criar o menu (explicado no próximo tópico), além dos ícones é necessário 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 programação.

Recursos de MenuNo Android o conteúdo dos menus fica organizado em um arquivo xml dentro da pasta res/menu.

Para criar o arquivo de recursos do menu, clique com o botão direito do mouse sobre a pasta menu e selecione a opção New > Android XML File:

Você não precisa fazer isso no momento, pois já foi criado um arquivo de menu para a aplicação:

Abra o arquivo:

Para adicionar um elemento ao menu clique no botão Add...:

Você também pode adicionar um item ou um group. O elemento item representa cada item de menu e o elemento group, que é opcional e invisível, permite agrupar itens de menu para a configuração de propriedades comuns (como estado, visibilidade). Selecione o elementoitem e clique em OK.

Note que há várias opções 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 exemploMude para o seguinte código-fonte:

<menu xmlns:android="http://schemas.android.com/apk/res/android" >    <item android:id="@+id/menu_archive" android:title="@string/menu_archive" android:icon="@drawable/ic_menu_archive"></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 função:

android:id: Identificar o item do menu via programação. 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. Utiliza-se @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. Utiliza-se @string/menu_archive para obter o texto a partir do arquivo de recursos.

Agora adicione os demais itens no arquivo:

<menu xmlns:android="http://schemas.android.com/apk/res/android" >    <item android:id="@+id/menu_archive"          android:title="@string/menu_archive"          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 menuPara utilizar o menu crie um novo arquivo de layout com dois TextView, conforme indicado no código abaixo:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"    android:layout_width="match_parent"    android:layout_height="match_parent" >    <TextView        android:id="@+id/textViewTitulo"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignParentLeft="true"        android:layout_alignParentTop="true"        android:layout_marginLeft="20dp"        android:layout_marginTop="20dp"        android:text="@string/titulo" />    <TextView        android:id="@+id/textViewResposta"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignLeft="@+id/textViewTitulo"        android:layout_below="@+id/textViewTitulo"        android:layout_marginTop="10dp"        android:text="@string/resposta" /></RelativeLayout>

Crie a seguinte activity:

import android.app.Activity;import android.os.Bundle;public class Tela8 extends Activity {    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_tela8);    }}

Para carregar o menu é preciso criar o método onCreateOptionsMenu, que será chamado no momento em que a activity for carregada. Dentro dele utilize o método inflate, da classe MenuInflater, para criar o menu, conforme o seguinte código:

import android.app.Activity;import android.os.Bundle;import android.view.Menu;public class Tela8 extends Activity {    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_tela8);    }    @Override    public boolean onCreateOptionsMenu(Menu menu) {        getMenuInflater().inflate(R.menu.activity_tela1, menu);        return true;    }}

Configure esta activity para activity inicial da aplicação:

<activity    android:name="br.com.treinaweb.parte1.Tela8"    android:label="@string/app_name" >    <intent-filter>        <action android:name="android.intent.action.MAIN" />        <category android:name="android.intent.category.LAUNCHER" />    </intent-filter></activity>

Em execuçãoExecute a aplicação:

Para exibir o menu, clique no botão Menu do emulador:

Ele será exibido:

Se você clicar em alguma das opções do menu nada irá acontecer ainda porque nenhuma ação foi configurada.

Obs: Os ícones do menu só aparecem nas versão 1.X e 2.X do Android. Como a aplicação não está sendo executada nessa versão, os ícones não serão exibidos.

Programando o menuQuando o usuário clicar em alguma das opções do menu, o sistema irá gerar o evento onOptionsItemSelected. Esse método recebe o item selecionado do menu como parâmetro, sendo poassível identificar o item através do método getItemId():

import android.app.Activity;import android.os.Bundle;import android.view.Menu;import android.view.MenuItem;import android.widget.TextView;public class Tela8 extends Activity {    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_tela8);    }    @Override    public boolean onCreateOptionsMenu(Menu menu) {        getMenuInflater().inflate(R.menu.activity_tela1, menu);        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 opção Arquivo";        break;      case R.id.menu_edit:        msg = "Selecionada a opção Editar";        break;      case R.id.menu_save:        msg = "Selecionada a opção Salvar";        break;      case R.id.menu_home:        msg = "Selecionada a opção Home";        break;      case R.id.menu_delete:        msg = "Seleionada a opção Excluir";        break;      case R.id.menu_more:        msg = "Selecionada a opção Mais";        break;      }      tvResposta.setText(msg);      return true;    }}

Execute a aplicação, exiba o menu e selecione uma opção:

Caixa de diálogoPode-se criar uma janela de diálogo para notificar o usuário, utilizando a classe AlertDialog.Builder.

Além de instanciar a classe AlertDialog.Builder é preciso configurar o texto da janela com o método setMessage, e o título com o métodosetTitle; resta ainda a opção de configurar um ícone com o método setIcon, e o botão com o método setNeutralButton. Por exemplo:

case R.id.menu_archive:

  AlertDialog.Builder mBox = new AlertDialog.Builder(this);

  mBox.setMessage("Selecionado a opção Arquivo");

  mBox.setTitle("Arquivo");

  mBox.setIcon(R.drawable.ic_menu_archive);

  mBox.setNeutralButton("OK", null);

  mBox.show();

  break;

Ao executar a aplicação e selecionar a opção de Arquivo:

Observe que a tela de trás perdeu o foco e a janela de diálogo está aguardando alguma interação com o usuário, que nesse caso só pode clicar no botão OK. Ao clicar no botão nenhuma ação será realizada, pois o evento do click do botão ainda não foi programado.

Para configurar o clique de um botão é preciso implementar a interface onClickListener. Assim como você implementou no CheckBox eRadioButon, implemente o evento onClick diretamente no parâmetro do método de definição do botão, conforme o código abaixo:

public boolean onOptionsItemSelected(MenuItem item){  final TextView tvResposta = (TextView) findViewById(R.id.textViewResposta);  String msg = "";  switch(item.getItemId()){  case R.id.menu_archive:    AlertDialog.Builder mBox = new AlertDialog.Builder(this);    mBox.setMessage("Selecionado a opção Arquivo");    mBox.setTitle("Arquivo");    mBox.setIcon(R.drawable.ic_menu_archive);    mBox.setNeutralButton("OK", new DialogInterface.OnClickListener() {      @Override      public void onClick(DialogInterface dialog, int which) {        // TODO Auto-generated method stub        tvResposta.setText("Botão OK Clicado");      }    });

    mBox.show();    break;...Note que o método onClick foi implementado diretamente no parâmetro do método setNeutralButton:

mBox.setNeutralButton("OK", new DialogInterface.OnClickListener() {  @Override  public void onClick(DialogInterface dialog, int which) {    // TODO Auto-generated method stub    tvResposta.setText("Botão OK Clicado");  }});Observe também que agora a variável tvStatus é final:

final TextView tvResposta = (TextView) findViewById(R.id.textViewResposta);

Execute a aplicação, exiba o menu e clique na opção Arquivo:

Clique no botão OK:

Configurando a janela de confirmaçãoOutra opção de janela de diálogo na classe AlertDialog.Builder é exibir uma janela de confirmação. Nesse caso o código é um pouco mais complexo, pois é preciso adicionar dois botões: a opção afirmativa, com o método setPositiveButton, e a opção negativa, com o método setNegativeButton. Por exemplo:

private void excluirCadastro(){  final TextView tvResposta = (TextView) findViewById(R.id.textViewResposta);  AlertDialog.Builder mBox = new AlertDialog.Builder(this);  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    public void onClick(DialogInterface dialog, int which) {      // TODO Auto-generated method stub      tvResposta.setText("Botão Sim clicado");    }  });  mBox.setNegativeButton("Não", new DialogInterface.OnClickListener() {    @Override    public void onClick(DialogInterface dialog, int which) {      // TODO Auto-generated method stub      tvResposta.setText("Botão Não clicado");    }  });  mBox.show();}

Chame o método na opção Excluir do menu:

case R.id.menu_delete:

  excluirCadastro();

  break;

Execute a aplicação e selecione a opção Excluir do menu:

Ao selecionar um botão, a mensagem será exibida no TextView:

SubmenusUm submenu nada mais é do que um menu que se abre ao ser clicado em algum dos itens. Sua utilização é recomendável quando a aplicação 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:

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

    <item android:id="@+id/menu_archive"          android:title="@string/menu_archive"          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">        <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 opção Mais (menu_more):

<item android:id="@+id/menu_more"      android:title="@string/menu_more"      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>Não é preciso configurar nada na activity, basta executar a aplicação e clicar na opção 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 método onOptionsItemSelected. Desta forma, para programar a resposta do submenu, basta adicionar no método onOptionsItemSelected as opções para identificar o item do submenu selecionado:

public boolean onOptionsItemSelected(MenuItem item){  final TextView tvResposta = (TextView) findViewById(R.id.textViewResposta);  String msg = "";  switch(item.getItemId()){  case R.id.menu_archive:    AlertDialog.Builder mBox = new AlertDialog.Builder(this);    mBox.setMessage("Selecionada a opção Arquivo");    mBox.setTitle("Arquivo");    mBox.setIcon(R.drawable.ic_menu_archive);    mBox.setNeutralButton("OK", new DialogInterface.OnClickListener() {      @Override      public void onClick(DialogInterface dialog, int which) {        // TODO Auto-generated method stub        tvResposta.setText("Botão OK Clicado");      }    });    mBox.show();    break;  case R.id.menu_edit:    msg = "Selecionada a opção Editar";    break;

  case R.id.menu_save:    msg = "Selecionada a opção Salvar";    break;  case R.id.menu_home:    msg = "Selecionada a opção Home";    break;  case R.id.menu_delete:    excluirCadastro();    break;  /*case R.id.menu_more:    msg = "Selecionado a opção Mais";    break;*/  case R.id.menu_search:    msg = "Selecionada a opção Pesquisar";    break;  case R.id.menu_attachment:    msg = "Selecionada a opção Adicionar arquivo";    break;  }  tvResposta.setText(msg);  return true;}Repare as últimas opções do switch:

/*case R.id.menu_more:  msg = "Selecionada a opção Mais";  break;*/case R.id.menu_search:  msg = "Selecionada a opção Pesquisar";  break;case R.id.menu_attachment:  msg = "Selecionada a opção Adicionar arquivo";  break;As opções do submenu foram configuradas e a exibição da mensagem da opção Mais do menu foi desabilitada.

Execute a aplicação e selecione a opção Mais:

Clique em alguma opção do menu:

Os itens do menu podem ser agrupados para configurar algumas das características comuns aos vários itens como, por exemplo, configurar todos os itens para ficar invisíveis ou desabilitados através dos atributos do grupo:

Faça este exemplo: configure todos para exibir um rádio:

<menu>    <group android:checkableBehavior="single" >     <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"/>    </group></menu>Ao executar, observe que todas as opções do submenu que pertencem a este grupo, passaram a ter um rádio:

Dispositivos sem botões físicosEm dispositivos que não possuírem o botão físico Menu, serão exibidos três pontos à direita na Action Bar – a barra no topo da aplicação, onde o menu pode ser acessado:

É possível emular esse cenário, definindo um dispositivo virtual com as características de um dispositivo que não possui botões físicos, como a configuração abaixo:

Na hora de executar a aplicação é necessário definir essa opção de emulador. Para isso, basta clicar com o botão direito do mouse sobre a aplicação, selecionar Run As > Run Configurations. Na caixa de diálogo que abrir, em Target, selecione o nome emulador:

Clique em Run para a aplicação ser executada:

Ao clicar nos três pontos, o menu será exibido da seguinte forma:

Também é possível exibir algumas opções do menu na Action Bar. Basta definir, na propriedade android:showAsAction, o comportamento do item de acordo com as opções abaixo:

ifRoom: Será exibido se houver espaço para isso. withText: Exibirá o título do item, se houver espaço. never: Nunca será exibido na Action Bar. always: Sempre exibir o item na Action Bar. Se exibir mais itens do que o espaço disponível, a Action Bar será sobreposta por outra Action Bar. Esse comportamento não é recomendado. collapseActionView: A view associada a esse item é “desomantável” – recurso introduzido na versão 14. (explicado no curso avançado).Por exemplo, se alterar o menu para:

<menu xmlns:android="http://schemas.android.com/apk/res/android" >    <item android:id="@+id/menu_archive"          android:title="@string/menu_archive"          android:icon="@drawable/ic_menu_archive"          android:showAsAction="ifRoom|withText"></item>    <item android:id="@+id/menu_edit"          android:title="@string/menu_edit"          android:icon="@drawable/ic_menu_edit"          android:showAsAction="ifRoom|withText"></item>    <item android:id="@+id/menu_save"          android:title="@string/menu_save"          android:icon="@drawable/ic_menu_save"          android:showAsAction="never"></item>    <item android:id="@+id/menu_home"          android:title="@string/menu_home"          android:icon="@drawable/ic_menu_home"

          android:showAsAction="never"></item>    <item android:id="@+id/menu_delete"          android:title="@string/menu_delete"          android:icon="@drawable/ic_menu_delete"          android:showAsAction="never"></item>    <item android:id="@+id/menu_more"          android:title="@string/menu_more"          android:icon="@drawable/ic_menu_more"          android:showAsAction="never">    <menu>        <group android:checkableBehavior="single" >         <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"/>        </group>    </menu>    </item></menu>Ele será exibido da seguinte forma:

Note que o que não foi exibido no Action Bar continua disponível no ícone dos três pontos.

O emulador com essa configuração é pesado, por isso altere novamente o target da aplicação e defina o antigo emulador:

Continue acompanhando o curso.

ToastOutra forma de notificar os usuários é utilizar a classe Toast. O Toast é um tipo de popup que aparece na tela, sempre em primeiro plano como a caixa de diálogo, por um período de tempo pré-definido.

Faça este exemplo: na activity Tela8, remova as linhas referentes à caixa de diálogo:

case R.id.menu_archive:  AlertDialog.Builder mBox = new AlertDialog.Builder(this);  mBox.setMessage("Selecionada a opção Arquivo");  mBox.setTitle("Arquivo");  mBox.setIcon(R.drawable.ic_menu_archive);  mBox.setNeutralButton("OK", new DialogInterface.OnClickListener() {    @Override    public void onClick(DialogInterface dialog, int which) {      // TODO Auto-generated method stub      tvResposta.setText("Botão OK Clicado");    }

  });  mBox.show();  break;Adicione o seguinte código:

case R.id.menu_archive:

  String texto = "Selecionada a opção 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 opção Arquivo";

Logo em seguida, foi pego o contexto em que a notificação irá aparecer:

Context context = getApplicationContext();

Ou seja, o contexto da aplicação.

Depois foi definida a duração da notificação:

int duracao = Toast.LENGTH_LONG;

Com as variáveis acima, foi criado o Toast:

Toast toast = Toast.makeText(context, texto, duracao);

E exibido:

toast.show();

Execute o aplicação, exiba o menu e clique na opção Arquivo:

IntentÉ uma estrutura de dados passiva que comporta uma descrição abstrata da operação a ser realizada. O Android utiliza os Intents para enviar mensagens entre os três principais componentes de uma aplicação (activitys, services e broadcast receivers). Essas mensagens podem ser enviadas dentro da mesma aplicação ou entre aplicações diferentes.

Por exemplo, é possível abrir uma nova activity com o seguinte código:

public void onClick(View v) {  Intent intencao = new Intent(this, Tela2.class);  startActivity(intencao);}Já para abrir outra aplicação como, por exemplo, o discador, utilize o código abaixo:

public void onClick(View v) {  Intent intencao = new Intent(Intent.ACTION_DIAL, Uri.parse("tel:05501126267282"));  startActivity(intencao);

}Adicione um botão no arquivo de layout do menu:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"    android:layout_width="match_parent"    android:layout_height="match_parent" >    <TextView        android:id="@+id/textViewTitulo"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignParentLeft="true"        android:layout_alignParentTop="true"        android:layout_marginLeft="20dp"        android:layout_marginTop="20dp"        android:text="@string/titulo" />    <TextView        android:id="@+id/textViewResposta"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignLeft="@+id/textViewTitulo"        android:layout_below="@+id/textViewTitulo"        android:layout_marginTop="10dp"        android:text="@string/resposta" />    <Button        android:id="@+id/buttonDiscar"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignLeft="@+id/textViewResposta"        android:layout_below="@+id/textViewResposta"        android:layout_marginTop="20dp"        android:text="@string/botao_discar" /></RelativeLayout>Agora, na activity, implemente a interface onClickListener no método setOnClickListener. Dentro do método onClick, coloque o código para abrir o discador do celular:

protected void onCreate(Bundle savedInstanceState) {    super.onCreate(savedInstanceState);    setContentView(R.layout.activity_tela8);    Button btnDiscar = (Button) findViewById(R.id.buttonDiscar);    btnDiscar.setOnClickListener(new View.OnClickListener() {    @Override    public void onClick(View arg0) {      Intent intencao = new Intent(Intent.ACTION_DIAL, Uri.parse("tel:05501126267282"));      startActivity(intencao);    }  });}Execute a aplicação:

Ao clicar no botão Discar, o discador do celular será aberto:

Intent implícitas e explícitasObserve que o código não informa uma classe:

Intent intencao = new Intent(Intent.ACTION_DIAL, Uri.parse("tel:05501126267282"));

Isso porque foi utilizado outro grupo de Intent, ou Intents implícitas, onde a classe-alvo não é nomeada. Ou seja: nas Intents implícitas não é informado ao sistema operacional qual a classe Java (seja uma activity, service ou broadcast receiver) será chamada. Ao invés disso um comando ou ação é informado, como no código acima (ou um filtro, explicado à frente). No código acima, no caso das Intents implícitas, também é permitido, opcionalmente, informar a URI que será utilizada para realizar a ação.

O primeiro exemplo de Intent:

Intent intencao = new Intent(this, Tela2.class);

Refere-se ao grupo de Intent explícitas, ou seja: é preciso informar exatamente o nome da classe que se quer abrir.

Como você deve ter reparado, as Intent explícitas são utilizadas para a comunicação interna de uma aplicação; e as implícitas, para comunicação com aplicações externas.

Intent FiltersAs atividades, serviços e broadcast receivers podem ter um ou mais intent filters para informar ao sistema quais intents implícitaspodem 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 não requeridos – mas apenas intents implícitas não requeridas. Uma intent explícita é sempre entregue a seu alvo, não importa o que contenha. O filtro simplesmente não é consultado. Mas uma intent implícita é entregue a um componente apenas se puder passar por algum dos filtros do componente que se quer que seja o alvo.

Assim como outras informações essenciais a respeito da aplicação, as Intent filters são declaradas no arquivo AndroidManifest.xml, como mostra o código abaixo:

<activity    android:name="br.com.treinaweb.parte1.Tela8"    android:label="@string/app_name" >    <intent-filter>        <action android:name="android.intent.action.MAIN" />        <category android:name="android.intent.category.LAUNCHER" />    </intent-filter></activity>Note que a activity Tela8 (no caso a Activity inicial) possui uma tag onde os filtros são criados em seu interior – podem passar ação, dados ou categoria a um objeto Intent. No exemplo acima, só foi criada uma ação (action), sendo que através dela a activity é localizada.

Você deverá criar um novo projeto para utilizar os filtros.

Feche o projeto atual, clique com o botão direito do mouse sobre o projeto e selecione Close Project:

Crie um novo projeto e selecione a opção do menu File > New > Android Application Project. A caixa de diálogo abaixo será exibida:

Preencha os dados, conforme a imagem acima, e clique em Next:

Marque as opções, conforme a imagem acima, e clique em Next:

Marque as opções, 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 código abaixo:

<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:id="@+id/textViewTitulo"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignParentLeft="true"        android:layout_alignParentTop="true"        android:layout_marginLeft="15dp"        android:layout_marginTop="15dp"        android:text="@string/titulo" />    <EditText        android:id="@+id/editTextNome"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignLeft="@+id/textViewTitulo"        android:layout_below="@+id/textViewTitulo"        android:layout_marginTop="15dp"        android:ems="10"        android:inputType="textPersonName"        android:text="@string/texto" >

        <requestFocus />    </EditText>    <Button        android:id="@+id/buttonProxima"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignLeft="@+id/editTextNome"        android:layout_below="@+id/editTextNome"        android:layout_marginTop="15dp"        android:text="@string/botao_proxima" />    <TextView        android:id="@+id/textViewRetorno"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        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 código:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"    android:layout_width="match_parent"    android:layout_height="match_parent" >    <TextView        android:id="@+id/textViewResposta"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignParentLeft="true"        android:layout_alignParentTop="true"        android:layout_marginLeft="15dp"        android:layout_marginTop="15dp"        android:text="@string/resposta" />    <EditText        android:id="@+id/editTextTexto"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignLeft="@+id/textViewResposta"        android:layout_below="@+id/textViewResposta"        android:layout_marginTop="15dp"        android:ems="10"        android:inputType="textPersonName"        android:text="@string/texto" >        <requestFocus />    </EditText>    <Button        android:id="@+id/buttonVoltar"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignLeft="@+id/editTextTexto"        android:layout_below="@+id/editTextTexto"        android:layout_marginTop="15dp"        android:text="@string/botao_voltar" />    <TextView        android:id="@+id/textViewRetorno"

        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignLeft="@+id/buttonVoltar"        android:layout_below="@+id/buttonVoltar"        android:layout_marginTop="15dp" /></RelativeLayout>

Para abrir este layout é preciso criar a activity abaixo:

import android.app.Activity;import android.os.Bundle;public class Tela2 extends Activity {  @Override  protected void onCreate(Bundle savedInstanceState) {    super.onCreate(savedInstanceState);    setContentView(R.layout.activity_tela2);  }}

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

<manifest xmlns:android="http://schemas.android.com/apk/res/android"    package="br.com.treinaweb.parte2"    android:versionCode="1"    android:versionName="1.0" >    <uses-sdk        android:minSdkVersion="8"        android:targetSdkVersion="17" />    <application        android:allowBackup="true"        android:icon="@drawable/ic_launcher"        android:label="@string/app_name"        android:theme="@style/AppTheme" >        <activity            android:name="br.com.treinaweb.parte2.Tela1"            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            android:name="br.com.treinaweb.parte2.Tela2"            android:label="@string/app_name"            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 opção action dentro das tags:

<intent-filter>    <action android:name="br.com.treinaweb.action.SUBACTIVITY" />    <category android:name="android.intent.category.DEFAULT" /></intent-filter>

Nessa opção foi criada a ação que será utilizada para referenciar a activity quando for chamada no código, conforme mostra o exemplo abaixo:

import android.os.Bundle;import android.app.Activity;import android.content.Intent;import android.view.Menu;import android.view.View;import android.view.View.OnClickListener;import android.widget.Button;public class Tela1 extends Activity implements OnClickListener {  @Override  protected void onCreate(Bundle savedInstanceState) {    super.onCreate(savedInstanceState);    setContentView(R.layout.activity_tela1);    Button btnProxima = (Button) findViewById(R.id.buttonProxima);    btnProxima.setOnClickListener(this);  }  @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;  }  @Override  public void onClick(View v) {    // TODO Auto-generated method stub    Intent intencao = new Intent("br.com.treinaweb.action.SUBACTIVITY");    startActivity(intencao);  }}

Note que desta vez não foi preciso informar o nome da classe, apenas o nome da ação definida no AndroidManifest.xml:

Intent intencao = new Intent("br.com.treinaweb.action.SUBACTIVITY");

Execute a aplicação e clique no botão:

Enviando dados para outra activityJá foi explicado que, para enviar dados para outra activity, é preciso criar um Bundle, adicionar os dados no padrão chave/valor e adicionar o Bundle na Intent, desta forma:

public void onClick(View v) {  // TODO Auto-generated method stub  Intent intencao = new Intent("br.com.treinaweb.action.SUBACTIVITY");  EditText txtNome = (EditText) findViewById(R.id.editTextNome);  String nome = txtNome.getText().toString();  Bundle parametros = new Bundle();  parametros.putString("nome", nome);  intencao.putExtras(parametros);  startActivity(intencao);}Mas também é possível adicionar os dados diretamente na Intent com o método putExtra, da seguinte forma:

public void onClick(View v) {  // TODO Auto-generated method stub  Intent intencao = new Intent("br.com.treinaweb.action.SUBACTIVITY");  EditText txtNome = (EditText) findViewById(R.id.editTextNome);  String nome = txtNome.getText().toString();  intencao.putExtra("nome", nome);  startActivity(intencao);}Já na activity que está recebendo os dados, o código não muda:

protected void onCreate(Bundle savedInstanceState) {  super.onCreate(savedInstanceState);  setContentView(R.layout.activity_tela2);  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:");  }  Button btnVoltar = (Button) findViewById(R.id.buttonVoltar);  btnVoltar.setOnClickListener(this);}É preciso pegar a Intent atual:

Intent intencao = getIntent();

Com ela, pegam-se os Extras:

Bundle extras = intencao.getExtras();

Como a activity pode ser chamada por qualquer aplicação que informe a sua ação (br.com.treinaweb.action.SUBACTIVITY) deve-se verificar se o Bundle é null, ou seja: se não possui nenhum valor:

if(extras == null) return;

Nesse caso, execute o return para finalizar a execução do evento onCreate.

Logo em seguida, pegue o valor da chave nome:

String nome = extras.getString("nome");

Depois verifique se a chave possui valor:

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

TextView tTitulo = (TextView) findViewById(R.id.textViewResposta);

tTitulo.setText(nome + " digite algo abaixo:");

Note também, no código acima, que o botão foi vinculado ao evento Click:

Button btnVoltar = (Button) findViewById(R.id.buttonVoltar);

btnVoltar.setOnClickListener(this);

No método onClick coloque o método finish() para voltar para a activity anterior:

public void onClick(View v) {  // TODO Auto-generated method stub  finish();}Adicione esse código na aplicação e execute o projeto:

Digite o seu nome e clique em Próxima:

Para finalizar e voltar, basta clicar no botão Voltar:

Recebendo dados de outra activityDa mesma forma que os dados podem ser enviados para outra activity na hora em que está sendo chamada, também 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 método startActivityForResult:

startActivityForResult(intencao, REQUEST_CODE);

Note que o método recebe opcionalmente um segundo parâmetro, o requestCode; se ele for positivo, e não ocorrer nenhum erro na subactivity, será retornado junto com os dados da subactivity. Esse código é utilizado para identificar a subactivity na hora em que está retornando um dado, já que não existe limite de quantas subactivities podem ser chamadas por uma activity.

É preciso retornar os dados na subactivity antes de finalizá-la, com o método setResult(resultCode, data). Onde resultCode pode serRESULT_CANCELED ou RESULT_OK, e data é uma Intent com os dados que serão retornados.

Observe que o método não recebe um identificador da subactivity. Por isso, o REQUEST_CODE foi utilizado no método acima.

O código na subactivity fica da seguinte forma:

import android.app.Activity;import android.content.Intent;import android.os.Bundle;import android.view.View;import android.view.View.OnClickListener;import android.widget.Button;import android.widget.EditText;import android.widget.TextView;public class Tela2 extends Activity implements OnClickListener {  @Override  protected void onCreate(Bundle savedInstanceState) {    super.onCreate(savedInstanceState);    setContentView(R.layout.activity_tela2);    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:");    }    Button btnVoltar = (Button) findViewById(R.id.buttonVoltar);    btnVoltar.setOnClickListener(this);  }

  @Override  public void onClick(View v) {    // TODO Auto-generated method stub    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 código do método onClick:

public void onClick(View v) {  // TODO Auto-generated method stub  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();}

Observe que foi criada uma Intent:

Intent data = new Intent();

Foi pego o texto do EditText:

EditText eTexto = (EditText) findViewById(R.id.editTextTexto);

String texto = eTexto.getText().toString();

E atribuído à Intent:

data.putExtra("texto", texto);

Depois foi passado para o método setResult:

setResult(RESULT_OK, data);

Para encerrar, finalizou-se a subactivity:

finish();

É preciso chamar o método setResult antes do método finish; caso contrário, não será executado.

Já na activity é preciso implementar o método onActivityResult. Esse método sempre será chamado quando uma subactivity retornar informações. Veja o código 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:

switch(requestCode){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:

if(resultCode == RESULT_OK)

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

if(data.hasExtra("texto"))

  result.setText(data.getExtras().getString("texto"));

Obs: Como a subactivity não será executada em modal pode retornar os dados assincronamente, mesmo sem a interação do usuário como, por exemplo, verificar um sms.

O código completo da classe ficará da seguinte forma:

import android.os.Bundle;import android.app.Activity;import android.content.Intent;import android.view.Menu;import android.view.View;import android.view.View.OnClickListener;import android.widget.Button;import android.widget.EditText;import android.widget.TextView;public class Tela1 extends Activity implements OnClickListener {  final int REQUEST_CODE = 1;  @Override  protected void onCreate(Bundle savedInstanceState) {    super.onCreate(savedInstanceState);    setContentView(R.layout.activity_tela1);    Button btnProxima = (Button) findViewById(R.id.buttonProxima);    btnProxima.setOnClickListener(this);  }

  @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;  }  @Override  public void onClick(View v) {    // TODO Auto-generated method stub    Intent intencao = new Intent("br.com.treinaweb.action.SUBACTIVITY");    EditText txtNome = (EditText) findViewById(R.id.editTextNome);    String nome = txtNome.getText().toString();    intencao.putExtra("nome", nome);    startActivityForResult(intencao, REQUEST_CODE);  }  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;    }  }}

Execute a aplicação, preencha seu nome e clique em Próximo:

Preencha algo:

Clique em Voltar:

Intents implícitas disponíveisNo começo do tópico sobre Intents foi explicado como abrir o discador do celular utilizando a ação ACTION_DIAL. Dessa mesma forma podem ser utilizadas outras ações que o Android disponibiliza para ter acesso às demais funções do sistema operacional e do aparelho.

As ações disponíveis mais utilizadas são:

ACTION_VIEW: Utilizado para visualizar o navegador, o mapa, os contatos e o discador. A opção correta será exibida de acordo com as informações do parâmetro URI. ACTION_DIAL: Exibe o discador. ACTION_CALL: Efetua uma chamada para o número 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 ações disponíveis, acesse o link: http://developer.android.com/reference/android/content/Intent.html

Acompanhe mais alguns exemplos, executando-os.

Efetuando uma chamada com um contato da agendaPara efetuar uma chamada utilizando um contato do celular, primeiro crie novo arquivo de layout, conforme o seguinte código:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"    android:layout_width="match_parent"    android:layout_height="match_parent" >    <TextView        android:id="@+id/textViewTitulo"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignParentLeft="true"        android:layout_alignParentTop="true"        android:layout_marginLeft="15dp"        android:layout_marginTop="15dp"        android:text="@string/rotulo" />    <ListView        android:id="@+id/listViewContatos"        android:layout_width="match_parent"        android:layout_height="wrap_content"        android:layout_alignLeft="@+id/textViewTitulo"        android:layout_below="@+id/textViewTitulo" >    </ListView></RelativeLayout>Note que foi utilizado um ListView para listar os contatos.

Para chamar o arquivo de layout e carregar os contados, crie a activity Tela3.java abaixo:

import android.app.Activity;import android.os.Bundle;public class Tela3 extends Activity {  protected void onCreate(Bundle savedInstanceState) {    super.onCreate(savedInstanceState);    setContentView(R.layout.activity_tela3);  }}

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;  }  @Override  public String toString(){    return name +  ": " + number;  }}

Utilize essa classe para organizar os contatos. Ela não é a melhor forma, como será explicado adiante, porque um contato pode ter mais de um número de telefone. Então, alguns contatos terão o mesmo nome, mas números de telefone diferentes. Como este exemplo é simples, você não precisa se preocupar com esse detalhe.

Observe que o método toString(), da classe objeto, foi sobescrito:

@Overridepublic String toString(){  return name +  ": " + number;}

Assim é possível controlar a exibição da classe Contact no widget ListView.

Já para carregar os contatos, é preciso criar o método getContacts() na activity Tela3 conforme o código 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.CommonDataKinds.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 oContact = new Contact();        oContact.setContactId(ContactID);        oContact.setName(name);        contacts.add(oContact);      }    }    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, null, null, null, null);

Para acessar os elementos do cursor foi cirado um laço 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 foi repetido para pegar o Nome e o HAS_PHONE_NUMBER:

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);

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 número 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, null);

O laço while foi utilizado novamente para percorrer o cursor:

while(phoneCursor.moveToNext()){Também foi pego o índice da coluna Number e o número do contato:

int indexNumber = phoneCursor.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER);

String number = phoneCursor.getString(indexNumber);

Logo em seguida, foi criada uma instância da classe Contact:

Contact oContact = new Contact();

O id, nome e o número do contato, foi setado no objeto da classe:

oContact.setContactId(ContactID);

oContact.setName(name);

oContact.setNumber(number);

E adicionado na lista o objeto da classe:

contacts.add(oContact);

Fora do laço while do número de telefone, o cursor foi fechado:

phoneCursor.close();

Se o contato não possuir telefone é criada uma nova instância; o id e nome do contato são setados ao objeto e adicionados na lista:

Contact oContact = new Contact();

oContact.setContactId(ContactID);

oContact.setName(name);

contacts.add(oContact);

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 código abaixo no método onCreate:

protected void onCreate(Bundle savedInstanceState) {  super.onCreate(savedInstanceState);  setContentView(R.layout.activity_tela3);  List<Contact> contatos = getContacts();  ArrayAdapter<Contact> oAdapter = new ArrayAdapter<Contact>(this, android.R.layout.simple_gallery_item, contatos);  ListView list = (ListView) findViewById(R.id.listViewContatos);  list.setAdapter(oAdapter);}Para ler os contatos é preciso adicionar, no AndroidManisfest.xml, a permissão abaixo:

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

Entre as tags uses-sdk e application, conforme o seguinte código:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"    package="br.com.treinaweb.parte2"    android:versionCode="1"    android:versionName="1.0" >    <uses-sdk        android:minSdkVersion="8"        android:targetSdkVersion="17" />    <uses-permission android:name="android.permission.READ_CONTACTS"/>    <application        android:allowBackup="true"        android:icon="@drawable/ic_launcher"        android:label="@string/app_name"        android:theme="@style/AppTheme" >        <activity            android:name="br.com.treinaweb.parte2.Tela1"            android:label="@string/app_name" >        </activity>        <activity            android:name="br.com.treinaweb.parte2.Tela2"            android:label="@string/app_name"            android:exported="false">            <intent-filter>                <action android:name="br.com.treinaweb.action.SUBACTIVITY" />                <category android:name="android.intent.category.DEFAULT" />            </intent-filter>        </activity>        <activity

            android:name="br.com.treinaweb.parte2.Tela3"            android:label="@string/app_name" >            <intent-filter>                <action android:name="android.intent.action.MAIN" />                <category android:name="android.intent.category.LAUNCHER" />            </intent-filter>        </activity>    </application></manifest>Note, também, que a activity Tela3 já foi definida como inicial:

<activity    android:name="br.com.treinaweb.parte2.Tela3"    android:label="@string/app_name" >    <intent-filter>        <action android:name="android.intent.action.MAIN" />        <category android:name="android.intent.category.LAUNCHER" />    </intent-filter></activity>Execute a aplicação:

Note que não foi listado nenhum contato porque, no moment,o não existe nenhum cadastrado no emulador. Para exibi-los, clique no botão Home:

A página 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 número de telefone selecionado, é preciso implementar na activity a interface onItemClickListener, o método onItemClick e associar o evento ItemClick ao widget ListView, conforme o seguinte código:

public class Tela3 extends Activity implements OnItemClickListener {  protected void onCreate(Bundle savedInstanceState) {    super.onCreate(savedInstanceState);    setContentView(R.layout.activity_tela3);    List<Contact> contatos = getContacts();    ArrayAdapter<Contact> oAdapter = new ArrayAdapter<Contact>(this, android.R.layout.simple_gallery_item, contatos);    ListView list = (ListView) findViewById(R.id.listViewContatos);    list.setAdapter(oAdapter);    list.setOnItemClickListener(this);  }  @Override  public void onItemClick(AdapterView<?> parent, View view, int position, long id) {    // TODO Auto-generated method stub  }  private List<Contact> getContacts(){...Obs: Esse é só um fragmento do código da classe.

Já no método onItemClick, adicione o código abaixo:

public void onItemClick(AdapterView<?> parent, View view, int position, long id) {  // TODO Auto-generated method stub  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 ação ACTION_CALL. Dessa forma, o telefone será chamado sem a necessidade de passar pelo discador.

Como explicado no início do curso, o Android separa todas as aplicações e, para uma aplicação acessar alguma área do sistema operacional, é necessário "pedir" permissão.

As permissões são informadas no arquivo AndroidManifest.xml, como foi feito para ter acesso à lista de contatos do celular. Com a lista de permissões necessárias da aplicação, o sistema Android pergunta ao usuário, no momento em que a aplicação está sendo instalada, se ele permite que ela tenha acesso às áreas solicitadas.

Para efetuar a ligação do número do telefone na aplicação, é preciso inserir a permissão CALL_PHONE no arquivo AndroidManisfest.xml, conforme o seguinte código:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"    package="br.com.treinaweb.parte2"    android:versionCode="1"    android:versionName="1.0" >    <uses-sdk        android:minSdkVersion="8"        android:targetSdkVersion="17" />    <uses-permission android:name="android.permission.READ_CONTACTS"/>    <uses-permission android:name="android.permission.CALL_PHONE"/>    <application        android:allowBackup="true"        android:icon="@drawable/ic_launcher"        android:label="@string/app_name"        android:theme="@style/AppTheme" >        <activity            android:name="br.com.treinaweb.parte2.Tela1"            android:label="@string/app_name" >        </activity>        <activity            android:name="br.com.treinaweb.parte2.Tela2"            android:label="@string/app_name"            android:exported="false">            <intent-filter>                <action android:name="br.com.treinaweb.action.SUBACTIVITY" />                <category android:name="android.intent.category.DEFAULT" />            </intent-filter>        </activity>        <activity            android:name="br.com.treinaweb.parte2.Tela3"            android:label="@string/app_name" >            <intent-filter>                <action android:name="android.intent.action.MAIN" />                <category android:name="android.intent.category.LAUNCHER" />            </intent-filter>        </activity>    </application></manifest>

Para conhecer todas as permissões possíveis, acesse a documentação oficial no link:http://developer.android.com/reference/android/Manifest.permission.html

Agora execute a aplicação:

Clique em um contato e o número será chamado:

Editando um contatoExistem duas formas de editar um contato: desenvolvendo uma tela para editar e programar todas as funções; ou utilizar a tela de edição da área de contatos do Android.

A primeira opção é explicada no curso intermediário. Para utilizar a activity de edição do Android, basta adicionar o código 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 ação ACTION_EDIT irá utilizar a activity de edição do Android, não é necessário colocar nenhuma permissão no arquivo AndroidManifest.xml.

A linha:

intent.putExtra(INTENT_KEY_FINISH_ACTIVITY_ON_SAVE_COMPLETED, true);

É necessária devido a um “bug” no Android 4.0. Se ela não for adicionada nas versões, ao final da edição, a aplicação da tela de edição não será chamada.

Também adicione a propriedade abaixo na activity Tela3, que é utilizada na opção acima.

public static final String INTENT_KEY_FINISH_ACTIVITY_ON_SAVE_COMPLETED = "finishActivityOnSaveCompleted";

Faça este exemplo: altere o método onItemClick e adicione o código abaixo:

public void onItemClick(AdapterView<?> parent, View view, int position, long id) {  // TODO Auto-generated method stub  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));  intent.putExtra(INTENT_KEY_FINISH_ACTIVITY_ON_SAVE_COMPLETED, true);  startActivityForResult(intent, REQUEST_CODE);}

Observe que foram passadas, no método startActivityForResult, além da Intent, a variável REQUEST_CODE criada no início da classe:

public class Tela3 extends Activity implements OnItemClickListener {  final int REQUEST_CODE = 1;

  protected void onCreate(Bundle savedInstanceState) {...Para verificar o retorno da activity, sobrescreva o método onActivityResult:

protected void onActivityResult(int requestCode, int resultCode, Intent data){  switch(requestCode){  case REQUEST_CODE:    if(resultCode == RESULT_OK){      List<Contact> contatos = getContacts();      ArrayAdapter<Contact> oAdapter = new ArrayAdapter<Contact>(this, android.R.layout.simple_gallery_item, contatos);      ListView list = (ListView) findViewById(R.id.listViewContatos);      list.setAdapter(oAdapter);    }    break;  }}Note que primeiro é verificado se houve alguma alteração nos contatos. Se sim, os contatos são listados novamente e o ListView é carregado.

Execute a aplicação:

Clique em algum contato e a tela de edição será aberta:

Efetue alguma alteração e clique em Done para voltar para a aplicação com a alteração 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 operação. No Android, para informar as aplicações sobre quais eventos estão sendo executados, ele utilizada o BroadcastReceiver.

O BroadcastReceiver também pode ser utilizado para que a aplicação 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 método onReceive().

Faça este exemplo: crie outra aplicação, chamada TerceiroProjeto, conforme as imagens a seguir:

Clique em Next:

Clique em Next:

Clique em Next:

Clique no botão 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;import android.content.Intent;public class Intercept extends BroadcastReceiver {  @Override  public void onReceive(Context arg0, Intent arg1) {    // TODO Auto-generated method stub  }}

O evento a ser “escutado” será o recebimento de uma ligação. Neste caso, é preciso registrar o receiver, da seguinte forma, no arquivoAndroidManifest.xml:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"    package="br.com.treinaweb.parte3"    android:versionCode="1"    android:versionName="1.0" >    <uses-sdk        android:minSdkVersion="9"        android:targetSdkVersion="17" />    <uses-permission android:name="android.permission.READ_PHONE_STATE" />

    <uses-permission android:name="android.permission.READ_CONTACTS" />    <application        android:allowBackup="true"        android:icon="@drawable/ic_launcher"        android:label="@string/app_name"        android:theme="@style/AppTheme" >        <activity            android:name="br.com.treinaweb.parte3.Tela1"            android:label="@string/app_name" >            <intent-filter>                <action android:name="android.intent.action.MAIN" />                <category android:name="android.intent.category.LAUNCHER" />            </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, além de registrar o receiver, também já foram adicionadas as permissões necessárias para escutar o evento de alguma mudança no estado do telefone e leitura de dados de contatos.

Volte ao receiver, no método onReceive, e adicione o seguinte código:

@Overridepublic void onReceive(Context context, Intent intent) {  // TODO Auto-generated method stub  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:

Bundle extras = intent.getExtras();

Se ela não possuir nenhum dado, cancela-se a execução do método:

if(extras == null)

  return;

Se ela possuir, é pego o estado do telefone:

String state = extras.getString(TelephonyManager.EXTRA_STATE);

Verifica-se se o estado dele é recebendo uma ligacão:

if (state.equals(TelephonyManager.EXTRA_STATE_RINGING)){Se sim, pega-se o número de telefone:

String phoneNumber = extras.getString(TelephonyManager.EXTRA_INCOMING_NUMBER);

Em seguida, o número é atribuído a um nome de remetente:

String fromDisplayName = "Desconhecido";

Adiante, será verificado se o número do remetente se encontra na agenda de contatos; se sim, este será o nome atribuído à variávelfromDisplayName.

Para pesquisar o contato, são criados o uri e o projection:

Uri uri;

String[] projection;

E atribuídos os valores às variáveis:

uri = Uri.withAppendedPath(

    ContactsContract.PhoneLookup.CONTENT_FILTER_URI,

    Uri.encode(phoneNumber));

projection = new String [] { ContactsContract.PhoneLookup.DISPLAY_NAME };

Na primeira variável foi criado um filtro para os contatos, de acordo com o número de telefone da ligação. 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:

Cursor cursor = context.getContentResolver().query(uri, projection, null, null, null);

Se ele encontrar algum contato pegará o nome retornado e atribuirá à variável fromDisplayName:

f(cursor != null){  if(cursor.moveToFirst())    fromDisplayName = cursor.getString(0);  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:

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);

Para exibir a mensagem na activity, primeiro é preciso adicionar dois TextView no arquivo de layout, conforme o código abaixo:

<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:id="@+id/textViewTitulo"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignParentLeft="true"        android:layout_alignParentTop="true"        android:layout_marginLeft="20dp"        android:layout_marginTop="20dp"        android:text="@string/titulo" />    <TextView        android:id="@+id/textViewRemente"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:layout_alignLeft="@+id/textViewTitulo"        android:layout_below="@+id/textViewTitulo"        android:layout_marginTop="20dp"        android:text="@string/remetente" />    <TextView        android:id="@+id/textViewTelefone"        android:layout_width="wrap_content"

        android:layout_height="wrap_content"        android:layout_alignLeft="@+id/textViewRemente"        android:layout_below="@+id/textViewRemente"        android:layout_marginTop="5dp"        android:text="@string/numero" /></RelativeLayout>No evento onCreate da activity, adicione o seguinte código:

@Overrideprotected void onCreate(Bundle savedInstanceState) {  super.onCreate(savedInstanceState);  setContentView(R.layout.activity_tela1);  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 = "Número: " + extra.getString("number");  }else{    remetente = "Nenhuma ligação recebida";  }  viewRemetente.setText(remetente);  viewNumero.setText(numero);}

Agora execute a aplicação para instalá-la no emulador:

Agora é preciso emular uma ligação para testar o aplicativo.

No Eclipse, selecione a opção Window > Show View > Other:

A caixa de diálogo abaixo será exibida:

Selecione a opção Emulador Control e clique em OK para exibir a seguinte aba no Eclipse:

No grupo Telephony Actions, no campo Incoming number, informe um número de telefone (pode ser um telefone falso) e selecione a opção Voice, conforme a imagem abaixo:

Clique em Call para efetuar a ligação. Como a ligação executa outra aplicação, antes de ela ser mostrada, a aplicação exibirá os dados no emulador:

E irá exibir o aplicativo Telefone:

Como a aplicação foi aberta um pouco antes, será exibida novamente quando a ligação for finalizada:

Se o número chamado for de algum contato, o respectivo nome será exibido:

NotificaçãoPara definir uma notificação da barra de status (no topo da tela), uma janela de Notificações e quaisquer outras configurações de alerta, usa-se a classe Notification.

Para criar uma notificação da barra de status é necessário ter:

Um ícone. O conteúdo da notificação. Um PedingIntent, que será adicionado quando a notificação 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 resolução:

Adicione as quatro imagens nas respectivas pastas do projeto, conforme indica a imagem abaixo:

Volte ao código.

A primeira coisa a criar é um objeto NotificationManager:

NotificationManager mNotificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERV

ICE);

Na linha seguinte é criado o PedingIntent:

PendingIntent contentIntent = PendingIntent.getActivity(context, 0, intencao, 0);

O PedingIntent é uma referência de uma Intent; no caso deste exemplo, referência à activity Tela1 que será aberta quando o usuário clicar na mensagem de notificação.

Em seguida são definidos os outros valores a serem apresentados na tela de notificação:

int icon = R.drawable.stat_sys_phone_call;

String titulo = "Telefonena de " + fromDisplayName;

String texto = "Ligação de " + fromDisplayName + " - " + phoneNumber;

long quando = System.currentTimeMillis();

A primeira variável é o ícone; a segunda, o título da mensagem que será exibida; a terceira, o texto da mensagem; e a quarta, contém o tempo corrente para informar ao usuário o horário em que a notificação foi ativada.

Logo em seguida, utiliza-se o NotificationCompat.Builder para criar um construtor para a notificação:

NotificationCompat.Builder builder = new NotificationCompat.Builder(context);

Antes era utilizado o próprio constructor da classe Notification, mas essa opção está obsoleta desde a versão 11 do Android. Agora é necessário utilizar NotificationCompat.Builder para

que a notificação seja compatível com qualquer versão Android. Se o aplicativo for desenvolvido para a versão 16 (Android 4.1) ou superior, é possível utilizar a classe Builder presente em Notification.

São definidas, nos métodos de builder, as informações da mensagem:

builder.setContentIntent(contentIntent)

  .setContentTitle(titulo)

  .setContentText(texto)

  .setSmallIcon(icon)

  .setWhen(quando);

Com esses dados, a notificação é criada:

Notification notification = builder.build();

Para finalizar, cria-se um id para a notificação e a inicia-se:

final int APP_NOTIFICATION_ID = 1;

mNotificationManager.notify(APP_NOTIFICATION_ID, notification);

Veja o código 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.content.Intent;import android.database.Cursor;import android.net.Uri;import android.os.Bundle;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) {    // TODO Auto-generated method stub    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);      NotificationManager mNotificationManager = (NotificationManager) context.getSystemService(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 = "Ligação 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 ligação:

Observe que a notificação aparece na barra de status. Se verificar, a notificação ficará visível:

Ao clicar na notificação a acitivity é aberta: