Android Apresentação

Prévia do material em texto

Faculdade 
7 de Setembro
CURSO ANDROID
MÓDULO BÁSICO
brunolopesjn@gmail.com
10/12/11
2Faculdade 
7 de Setembro
Who I am?
● Bruno Lopes A. Batista
● Bacharel em Sistemas de 
Informação pela Faculdade de 
Juazeiro do Norte.
● Pós Graduando na Especialização 
de Desenvolvimento Web com 
Java EE.
● Programador Java desde 2008
● Desenvolvedor Android desde 
2010.
● Administrador De redes Linux 
desde 2002.
brunolopesjn@gmail.com
10/12/11
3Faculdade 
7 de Setembro
Who are you?
brunolopesjn@gmail.com
10/12/11
4Faculdade 
7 de Setembro
Cronograma
● Apresentando o Android
● Conceitos básicos
● Activity
● Intent
● Interface Gráfica
brunolopesjn@gmail.com
10/12/11
5Faculdade 
7 de Setembro
Dicas
● Coloque o celular no silencioso, assim você não atrapalha o 
professor e nem seus colegas.
● Caso for atender o celular, saia da sala primeiro e depois 
atenda.
● Evite conversas paralelas!
● Envolva-se com a aula! Seu aproveitamento será melhor.
● Com dúvidas sobre um tópico apresentado? Pergunte! A sua 
dúvida também pode ser a dúvida do colega.
● Se você tem uma critica (construtiva) ou uma sugestão, sinta-
se livre para expor.
brunolopesjn@gmail.com
10/12/11
6Faculdade 
7 de Setembro
Dicas
E a dica mais importante!
brunolopesjn@gmail.com
10/12/11
7Faculdade 
7 de Setembro
Dica
Sempre utilize a combinação de teclas CTRL + SPACE BAR 
(CONTROL + BARRA DE ESPAÇO) quando estiver digitando os 
códigos no Eclipse (IDE).
Instruções de Uso:
● Primeiro digite o começo do texto.
● Depois pressione, e mantenha pressionado, a tecla CONTROL.
● Em seguida pressione a tecla BARRA DE ESPAÇO.
● E como mágica a IDE irá terminar o preenchimento do texto!
+
brunolopesjn@gmail.com
10/12/11
8Faculdade 
7 de Setembro
APRESENTANDO O ANDROID
brunolopesjn@gmail.com
10/12/11
9Faculdade 
7 de Setembro
Plataforma Android!
● O Android é um ambiente de desenvolvimento de software para 
dispositivos móveis.
● Não é um ambiente de hardware!
● Está incluso na plataforma Android:
● Um kernel (núcleo), baseado no kernel 2.6 do Linux;
● Uma rica interface de usuário (UI);
● Aplicações;
● Bibliotecas;
● Frameworks;
● E muito mais!!!
brunolopesjn@gmail.com
10/12/11
10Faculdade 
7 de Setembro
Plataforma Android
● Uma característica muito importante da plataforma, é que ela 
não diferencia aplicações nativas das que VOCÊ irá criar!
● Utiliza-se a linguagem de programação Java para desenvolver 
aplicações para a plataforma Android.
brunolopesjn@gmail.com
10/12/11
11Faculdade 
7 de Setembro
Kernel Linux
● O Android foi construído sobre uma versão do kernel do Linux.
● Isso permite que a plataforma Android possa ser portada para 
outras plataforma facilmente.
● O kernel do Linux possui uma plataforma completa de 
recursos, o que provê uma tremenda força e capacidade para a 
plataforma Android.
● Por ser de código aberto, permite que talentos individuais e 
companhias portem o Android para outras plataformas ou 
melhorem-no ainda mais.
brunolopesjn@gmail.com
10/12/11
12Faculdade 
7 de Setembro
Dalvik VM
● O elemento chave da plataforma Android é a máquina virtual 
Dalvik.
● Ao invés de usar uma versão da máquina virtual Java, tal como 
o Java ME, ele usa a sua própria máquina virtual.
● A máquina virtual Dalvik possui as seguintes características:
● Poder existir múltiplas instâncias da máquina virtual 
simultaneamente;
● Baixo consumo de memória;
● Mais eficiente do que uma máquina virtual Java.
brunolopesjn@gmail.com
10/12/11
13Faculdade 
7 de Setembro
Então, se não existe uma máquina virtual Java,
como o código Java feito para o Android funciona???
brunolopesjn@gmail.com
10/12/11
14Faculdade 
7 de Setembro
Dalvik VM
● No nível mais alto, o código gerado para Android é código Java 
(bytecode).
● Porém, o bytecode java é transformado em uma representação 
similar, mas diferente, chamada de Dalvik Executable ou dex 
files.
● Os arquivos dex são executados dentro da maquina virtual 
Dalvik.
● O conjunto de arquivos dex, geram um arquivo apk (Android 
Package), que é instalador propriamente dito.
brunolopesjn@gmail.com
10/12/11
15Faculdade 
7 de Setembro
Android Market
● O Android Market é um repositórios de aplicações Android.
● O desenvolvedor pode disponibilizar aplicativos gratuitos ou 
pagos no Android Market.
● 70% dos lucro obtidos com a venda de um aplicativo, é 
destinado ao desenvolvedor do mesmo!
● Para poder enviar aplicativos para o Android Market é 
necessário realizar um cadastro, muito parecido com o do 
youtube, e pagar uma taxa de US$ 25,00.
● Todos os dispositivos suportam o Android Market. (Já vi um 
aparelho Dell vendido pela operadora Claro com o Android 
Market bloqueado).
brunolopesjn@gmail.com
10/12/11
16Faculdade 
7 de Setembro
Configuração do ambiente
● Em meu blog pessoal, exitem 4 vídeos onde explico a 
configurar o ambiente de desenvolvimento:
● Instalando o Java (Windows)
● Instalando o SDK do Andoird (Windows)
● Instalando o Java (Linux)
● Instalando o SDK do Andoird (Linux)
● Neste laboratório o ambiente já esta configurado!
● Poupar tempo! Time is knowledge!
● Dúvidas sobre a configuração do ambiente postem em meu 
blog ou me enviem um e-mail.
brunolopesjn@gmail.com
10/12/11
17Faculdade 
7 de Setembro
Qual é o endereço do seu blog?
Qual é o seu endereço de e-mail?
brunolopesjn@gmail.com
10/12/11
18Faculdade 
7 de Setembro
CONTATOS
BLOG
http://kariridev.blogspot.com
E-MAIL
brunolopesjn@gmail.com
brunolopesjn@gmail.com
10/12/11
19Faculdade 
7 de Setembro
CONCEITOS 
BÁSICOS
brunolopesjn@gmail.com
10/12/11
20Faculdade 
7 de Setembro
Activity
brunolopesjn@gmail.com
10/12/11
21Faculdade 
7 de Setembro
Activity
● Uma Activity (atividade) representa uma interface de usuário no 
Android.
● Toda interface de usuário de sua aplicação será herdada da 
classe abstrata Activity.
● Uma activity utiliza-se de componentes para criar interfaces de 
usuário que mostram informações e respondem a ações do 
usuário.
● Em um projeto real, provavelmente você usará varias activitys, 
onde cada uma representará uma janela.
● A activity é um dos componentes Android mais utilizados em 
uma aplicação.
brunolopesjn@gmail.com
10/12/11
22Faculdade 
7 de Setembro
Activity
package br.com.cassic.treinamento;
import android.app.Activity;
import android.os.Bundle;
public class MainActivity extends Activity {
 
 @Override
 public void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.main);
 }
}
brunolopesjn@gmail.com
10/12/11
23Faculdade 
7 de Setembro
Activity
● O método onCreate(Bundle) deve ser SEMPRE implementado 
em uma activity.
● O método onCreate(Bundle) sempre será o primeiro método a 
ser executado quando uma activity for iniciada.
● A chamada do método setContentView(View) SEMPRE deve 
estar presente no método onCreate(Bundle) de uma activity.
● O método setContentView recebe como parâmetro um objeto 
do tipo View, que define a interface de usuário.
● Cada activity deve ser declarada no arquivo 
AndroidManifest.xml.
● A activity possui um ciclo de vida bem definido.
brunolopesjn@gmail.com
10/12/11
24Faculdade 
7 de Setembro
Layout
brunolopesjn@gmail.com
10/12/11
25Faculdade 
7 de Setembro
Layout
● O Android é bastante flexível em relação à criação de layouts.
● O layout das interfaces de usuário (janelas) podem ser feitas, 
no Android, de duas maneiras:
● Programaticamente, muito parecido com o SWING.
● Declarativamente, por meio de um arquivo XML.
●Neste curso criaremos as interfaces de forma declarativa, via 
XML.
● Este arquivo de XML com o layout deve estar na pasta 
/res/layout.
brunolopesjn@gmail.com
10/12/11
26Faculdade 
7 de Setembro
Layout
<?xml version="1.0" encoding="utf-8"?>
 <LinearLayout mlns:android="http://schemas.android.com/apk/res/android"
 android:orientation="vertical"
 android:layout_width="fill_parent"
 android:layout_height="fill_parent">
 <TextView 
 android:layout_width="fill_parent"
 android:layout_height="wrap_content"
 android:text="@string/hello"/>
</LinearLayout>
brunolopesjn@gmail.com
10/12/11
27Faculdade 
7 de Setembro
AndroidManifest.xml
brunolopesjn@gmail.com
10/12/11
28Faculdade 
7 de Setembro
AndroidManifest.xml
● O arquivo AndroidManifest.xml é o alicerce de uma aplicação 
Android.
● Este arquivo deve estar na raiz da aplicação.
● Este arquivo serve para:
● Descrever o contexto da aplicação;
● Activitys, Services, Content Providers e Broadcast Receivers 
suportados pela aplicação;
● Permissões necessárias para a aplicação utilizar os recursos de 
hardware e software.
● Entre outras funções
brunolopesjn@gmail.com
10/12/11
29Faculdade 
7 de Setembro
AndroidManifest.xml
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
 package="br.com.cassic.treinamento"
 android:versionCode="1"
 android:versionName="1.0">
 <uses-sdk android:minSdkVersion="7" />
 <application android:icon="@drawable/icon" android:label="@string/app_name">
 <activity android:name=".MainActivity"
 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>
brunolopesjn@gmail.com
10/12/11
30Faculdade 
7 de Setembro
A classe R
brunolopesjn@gmail.com
10/12/11
31Faculdade 
7 de Setembro
A classe R
● As interfaces de usuário podem ser criadas de duas maneiras:
● Programaticamente, de forma similar ao SWING.
● Ou declarativamente por xml, abordagem que utilizaremos nesse 
curso.
● No final teremos um objeto do tipo View com todos os 
componentes da interface de usuário.
● Uma referência desse objeto do tipo View deve ser passado 
para o método setContentView() para que a interface de 
usuário seja criada.
brunolopesjn@gmail.com
10/12/11
32Faculdade 
7 de Setembro
Como irei obter uma referência 
do objeto View criado 
a partir de um XML???
brunolopesjn@gmail.com
10/12/11
33Faculdade 
7 de Setembro
A classe R
● Para obter a referência de um objeto View criado por XML, 
utilizamos a classe R.
● A classe R é uma classe que possui métodos estáticos com as 
referências de todos os objetos criados via XML.
● As estradas estáticas são criadas automaticamente graças ao 
plugin ADT, instalado no eclipse.
● Toda alteração no XML, será automaticamente replicado na 
classe R.
● Esta classe NUNCA deve ser alterada manualmente.
● Se acidentalmente, ou propositalmente, você apagar a classe 
R, basta fazer um clean no projeto.
brunolopesjn@gmail.com
10/12/11
34Faculdade 
7 de Setembro
A classe R
package br.com.cassic.treinamento;
public final class R {
 public static final class attr {
 }
 public static final class drawable {
 public static final int icon=0x7f020000;
 }
 public static final class layout {
 public static final int main=0x7f030000;
 }
 public static final class string {
 public static final int app_name=0x7f040001;
 public static final int hello=0x7f040000;
 }
}
brunolopesjn@gmail.com
10/12/11
35Faculdade 
7 de Setembro
Acessando 
elementos 
visuais
brunolopesjn@gmail.com
10/12/11
36Faculdade 
7 de Setembro
Acessando elementos 
visuais
● A classe R disponibiliza uma forma de acessar uma referência 
de um objeto do tipo View, criado a partir de um arquivo XML.
● Para utilizar essa referencia em um código Java, deve ser 
criado um objeto do mesmo tipo.
● Para isso utilizamos o método findViewById(id), onde o id é a 
referência disponibilizada pela classe R do objeto a ser 
referenciado.
● SEMPRE deverá ser feito uma conversão (cast) do objeto que 
está sendo referenciado.
brunolopesjn@gmail.com
10/12/11
37Faculdade 
7 de Setembro
Acessando elementos 
visuais
package br.com.cassic.treinamento;
import android.app.Activity;
import android.os.Bundle;
import android.widget.EditText;
public class MainActivity extends Activity {
 @Override
 public void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.main);
 EditText caixa_texto = (EditText) findViewById(R.id.caixa_texto);
 }
}
brunolopesjn@gmail.com
10/12/11
38Faculdade 
7 de Setembro
Tratamento de 
eventos
brunolopesjn@gmail.com
10/12/11
39Faculdade 
7 de Setembro
Tratamento de eventos
● Quando desenvolvemos aplicativos, devemos sempre ter a 
preocupação de garantir que ela interaja com o usuário e 
atenda as suas expectativas.
● Para tanto, a plataforma Android disponibiliza uma grande 
quantidade de Listeners (ouvintes) para capturar eventos.
● O listener para capturar os eventos de um botão é o 
setOnClickListener(listener).
● Para usa-lo, deve-se primeiramente implementar (implements) 
a interface OnClickListener, no caso de um botão.
● Ao implementar a interface OnClickListener será criado o 
método onClick(View), que será chamado automaticamente 
quando acontecer um evento.
brunolopesjn@gmail.com
10/12/11
40Faculdade 
7 de Setembro
Tratamento de Eventos
public class MainActivity extends Activity implements OnClickListener{ 
 
 @Override
 public void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.main);
 Button botao = (Button) findViewById(R.id.botao);
 botao.setOnClickListener(this);
 }
 @Override
 public void onClick(View v) {
 // Implementar aqui o que fazer
 // quando acontecer um evento.
 }
}
brunolopesjn@gmail.com
10/12/11
41Faculdade 
7 de Setembro
LogCat
brunolopesjn@gmail.com
10/12/11
42Faculdade 
7 de Setembro
LogCat
● O método System.out.println(), muito utilizado no Java para imprimir 
uma mensagem na tela, não funciona no Android (pelo menos não 
deveria).
● Isso porque na máquina virtual Dalvik o stdout e o stderr (System.out 
e System.err) redirecionam sua sída para a pasta /dev/null (é o que 
diz a documentação, mas na prática...).
● A classe Log permite que você crie logs de informação, debug, 
alertas e erro.
● Os logs funcionam de forma similar ao framework Log4J da Jakarta.
● Os logs são apresentados na ferramenta LogCat, que fica na 
perspectiva DDMS.
● É possível criar tags para filtrar os logs.
brunolopesjn@gmail.com
10/12/11
43Faculdade 
7 de Setembro
LogCat
public class MainActivity extends Activity implements OnClickListener{
 
 @Override
 public void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.main);
 
 Log.i("TAG", "Mensagem de Log");
 }
}
brunolopesjn@gmail.com
10/12/11
44Faculdade 
7 de Setembro
Exercícios
brunolopesjn@gmail.com
10/12/11
45Faculdade 
7 de Setembro
Exercícios
● Criar o nosso primeiro projeto Android (Projeto01).
● Criar um layout com XML com os seguintes componentes:
● TextView - Label
● EditText – Textbox
●Button
● TextView – Label
● Gerenciar o evento do clique do botão.
● Ao clicar no botão, o texto digitado no textbox deve ser exibido no 
segundo TextView (Label).
● Exibir uma mensagem de log no LogCat quando o botào for clicado.
● Testar o método System.out.println().
brunolopesjn@gmail.com
10/12/11
46Faculdade 
7 de Setembro
ACTIVITY
brunolopesjn@gmail.com
10/12/11
47Faculdade 
7 de Setembro
Activity
● Como visto anteriormente, a principal função da activity é de 
criar janelas/interfaces.
● Cada Activity deve, obrigatoriamente, implementar o método 
onCreate(Bundle).
● O método setContentView(View) deve ser chamado dentro do 
método onCreate(Bundle).
● Cada activity de ser declarada no arquivo AndroidManifest.xml.
● Neste momento, iremos estudar a classe Activity com mais 
detalhes.
brunolopesjn@gmail.com
10/12/11
48Faculdade 
7 de Setembro
Ciclo de vida 
da Activity
brunolopesjn@gmail.com
10/12/11
49Faculdade 
7 de Setembro
Ciclo de vida da Activity
brunolopesjn@gmail.com
10/12/11
50Faculdade 
7 de Setembro
 Ciclo de vida da Activity
● A activity é gerenciada, pelo Android, como uma pilha (stack) 
de activities.
● Quando uma nova activity é iniciada, a mesma fica no topo da 
pilha (stack), tornando-se a activity em execução.
● A activity anterior estará logo abaixo a activity em execução na 
pilha de activity, e ela não estará visível enquanto a activity em 
execução existir.
● O ciclo de vida de uma activity pode ser dividido em três 
momentos: Entire lifetime; Visible lifetime; Foreground 
lifetime.
brunolopesjn@gmail.com
10/12/11
51Faculdade 
7 de Setembro
Ciclo de vida da Activity
● Visible lifetime
● A activity está criada, mas pode estar no topo da pilha 
interagindo com o usuário ou temporariamente parada em 
segundo plano.
● Este ciclo ocorre entre os métodos onStart() e o onStop().
● A activity fica no topo da pilha quando o método 
onResume() é chamado.
● Este ciclo engloba todo o tempo que a activity está no topo 
ou está em segundo plano esperando outra activity terminar.
● Sempre que o método onStart() é chamado, o método 
onResume() também é invocado.
brunolopesjn@gmail.com
10/12/11
52Faculdade 
7 de Setembro
Ciclo de vida da Activity
● Entire lifetime
● Ciclo de vida completo entre o início e destruição da activity.
● Este ciclo ocorre apenas uma única vez.
● Ele acontece entre as chamadas dos métodos 
onCreate(Bundle) e onDestroy().
● Ambos os métodos onCreate(Bundle) e onDestroy() são 
executados uma única vez, quando a activity é criada e 
destruída, respectivamente.
brunolopesjn@gmail.com
10/12/11
53Faculdade 
7 de Setembro
Ciclo de vida da Activity
● Foreground lifetime 
● A activity está no topo da pilha e interagindo com o usuário.
● Este ciclo ocorre entre os métodos onResume() e 
onPause().
● O celular chama o método onPause(), por exemplo, quando 
o celular “dorme” para economizar energia.
● Quando o usuário ativa o celular novamente, o método 
onResume() é chamado.
● É recomendado que o código executado nesses métodos 
seja bem leve e rápido, sendo que este ciclo pode ser 
executado várias vezes.
brunolopesjn@gmail.com
10/12/11
54Faculdade 
7 de Setembro
Navegando 
entre 
Activities
brunolopesjn@gmail.com
10/12/11
55Faculdade 
7 de Setembro
Navegação entre Activities
● Até agora, criamos aplicações com apenas uma única tela.
● No entanto, em aplicações mais complexas, será necessário 
criar várias telas e um fluxo de navegação entre elas.
● Para isso existem dois métodos para iniciar uma activity:
● startActivity(Intent);
● startActivityFromResult(Intent, int).
● A classe Intent será explicada mais adiante com mais detalhes, 
mas ela é usada para enviar uma mensagem para o Android.
● Enquanto não abordamos a Intent pratique um ato de fé, amor 
e caridade acreditando no que eu digo quando se referir a 
Intents.
brunolopesjn@gmail.com
10/12/11
56Faculdade 
7 de Setembro
Navegação entre Activitys
● O método startActivity(Intent) inicia uma activity previamente 
declarada no arquivo AndroidManifest.xml.
● Para tando, devemos criar uma Intent que enviará uma 
mensagem para o Android solicitando a abertura da interface.
● Ao abrir uma nova Activity, ela estará automaticamente no topo 
da pilha de activitys.
● Porém ao ser fechada, a activity anterior voltará para o topo da 
pilha.
brunolopesjn@gmail.com
10/12/11
57Faculdade 
7 de Setembro
Navegação entre Activities
public class MainActivity extends Activity{
 
 @Override
 public void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.main);
 
 Intent intent = new Intent(this, Outra_Activity.class);
 
 startActivity(intent);
 
 }
}
brunolopesjn@gmail.com
10/12/11
58Faculdade 
7 de Setembro
Navegação entre Activities
● O método startActivity(Intent) apenas solicita a execução de 
uma outra Actitivy.
● Por esta razão, não é possível retornar dados para a activity 
que a invocou.
● O método startActivityForResult(Intent, int) alem de fazer o 
mesmo que o método startActivity(Intent), permite retornar dados 
para a activity que o invocou.
● O parâmetro inteiro do método startActvityForResult(Intent, int) 
é um identificador da chamada da activity.
brunolopesjn@gmail.com
10/12/11
59Faculdade 
7 de Setembro
Navegação entre Activities
public class MainActivity extends Activity{
 
 @Override
 public void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.main);
 Intent intent = new Intent(this, MainActivity.class);
 startActivityForResult(intent, 0);
 }
 
 @Override
 protected void onActivityResult(int requestCode, int 
resultCode, Intent data) {
 super.onActivityResult(requestCode, resultCode, data);
 if(requestCode == 0){
 //Executa alguma coisa
 }
 }
}
brunolopesjn@gmail.com
10/12/11
60Faculdade 
7 de Setembro
Navegação de Activities
● Quando usamos o método startActivityForResult(Intent, int), 
devemos implementar o método onActivityResult(int, int, 
Intent).
● Este método será executado quando a activity invocada for 
finalizada.
● Neste momento poderá ser realizado algum tratamento de 
informações que foram retornadas da activity.
brunolopesjn@gmail.com
10/12/11
61Faculdade 
7 de Setembro
Passagem de 
parâmetro 
entre Activities
brunolopesjn@gmail.com
10/12/11
62Faculdade 
7 de Setembro
Passagem de parâmetros 
entre Activities
● Agora como já sabemos como navegar entre activities, vamos 
verificar como passar parâmetros entre activities.
● Para tanto existe a classe Bundle, que funciona de forma 
similar a uma HashTable.
● Para passar parâmetros para a activity a ser invocada, basta 
criarmos uma instancia da classe Bundle, adicionamos os 
valores pretendidos a ela, e atribuímos a uma Intent.
● Para atribuir a uma Intent, usamos o método putExtras de uma 
Intent.
brunolopesjn@gmail.com
10/12/11
63Faculdade 
7 de Setembro
Passagem de parâmetros
entre activities
public class MainActivity extends Activity{
 
 @Override
 public void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.main); 
 Intent intent = new Intent(this, MainActivity.class); 
 Bundle bundle = new Bundle(); 
 bundle.putString("nome", "Bruno Lopes"); 
 intent.putExtras(bundle); 
 startActivity(intent); 
 }
}
brunolopesjn@gmail.com
10/12/11
64Faculdade 
7 de Setembro
Passagem de parâmetrosentre Activities
● Para ler os parâmetros passados de uma activity para a outra, 
basta recuperar a instancia da classe Bundle.
● Primeiramente recuperamos a instancia da Intent da Activity 
que recebeu os parâmetros
● Depois recuperamos a instancia da classe Bundle que foi 
passada como parâmetro para a Intent.
● Em seguida, basta lermos o conteúdo do Bundle com o método 
apropriado.
brunolopesjn@gmail.com
10/12/11
65Faculdade 
7 de Setembro
Encerrando uma Activity
● O Android gerencia automaticamente o ciclo de vida da activity.
● Quando for necessário encerrar uma activity ou colocá-la em 
segundo plano , o Android o fará automaticamente.
● Caso seja necessário fechar uma activity e ter certeza que ela 
será eliminada da memória, podemos executar o método 
finish().
● Ao chamar o método finish(), será automaticamente chamado o 
método onDestroy() da Activity e a mesma será eliminada da 
memória.
brunolopesjn@gmail.com
10/12/11
66Faculdade 
7 de Setembro
Exercícios
brunolopesjn@gmail.com
10/12/11
67Faculdade 
7 de Setembro
Exercícios
● Crie um projeto chamado Projeto02.
● Crie mais duas activitys com nome Activity1 e Actvity2.
● Faça o log de cada método do ciclo de vida de todas as 
Activitys.
● Na activity principal, crie dois botões que permitam abrir, 
respectivamente, a Activity1 e Activity2.
● Na Activity1, adicione um EditText e um Button. Quando o 
usuário digitar o seu nome no EditText e presionar o Button, 
retornar para a activity principal e exibir o nome digitado pelo 
usuário em um TextView e encerrar a Activity1.
● Passar a data de hoje (em milisegundos) como parâmetro para 
a Activity2.
brunolopesjn@gmail.com
10/12/11
68Faculdade 
7 de Setembro
INTENT
brunolopesjn@gmail.com
10/12/11
69Faculdade 
7 de Setembro
Intent
● Uma Intent representa uma “ação” que a aplicação deseja 
executar.
● A Intent é um mecanismo de mensagem que trabalha com a 
sua aplicação ou ente aplicações.
● Intent pode ser usada para:
● Declarar a sua intenção de uma Activity ou um Service de 
executar uma ação.
● Enviar mensagens de Broadcast ao sistema, notificando alguma 
ação que tenha ocorrido.
● Iniciar explicitamente alguma Activity ou Service.
brunolopesjn@gmail.com
10/12/11
70Faculdade 
7 de Setembro
Intent
● É possível invocar as aplicações nativas do Android através 
das Intents.
● Vimos anteriormente que para abrir uma activity, utilizamos o 
construtor da classe Intent que recebe a classe Activity a ser 
iniciada.
● Entretanto, existe um outro construtor que recebe uma string.
● Essa string representa uma ação a ser executada pelo sistema 
operacional.
● O valor dessa string pode ser qualquer coisa como, por 
exemplo, “rapadura”, “piqui”, “chocolate”, contento que faça 
sentido para a aplicação que está sendo desenvolvida.
brunolopesjn@gmail.com
10/12/11
71Faculdade 
7 de Setembro
Intent
● Por exemplo, poderíamos usar o seguinte trecho de código 
para abrir uma activity:
● Intent it = new Intent(“ABRIR_ACTIVITY”);
● startActivity(it);
● Essa Intent, representa uma mensagem que é enviada ao 
sistema operacional.
Qual aplicação responderá
a esta mensagem?
brunolopesjn@gmail.com
10/12/11
72Faculdade 
7 de Setembro
Intent
● Pode ser a sua aplicação ou qualquer outra aplicação.
● Isso é a grande sacada e é o interessante sobre esta 
arquitetura.
● O próprio Android, já traz consigo algumas ações-padrão que 
ao serem requisitadas executam algumas tarefas.
● Veremos como utilizar algumas dessas ações.
brunolopesjn@gmail.com
10/12/11
73Faculdade 
7 de Setembro
Abrindo o 
Browser
brunolopesjn@gmail.com
10/12/11
74Faculdade 
7 de Setembro
Abrindo o browser
● Suponha que você esteja criando uma aplicação que, por algum motivo, 
necessite abrir o browser em um determinado site da internet.
● Isso é uma tarefa relativamente simples de executar no Android.
● Podemos utilizar uma Intent com a ação Intent.ACTION_VIEW, para abrir o 
browser no endereço desejado.
● No momento que o método startActivity() é chamado, é enviado uma 
mensagem ao sistema operacional requisitando a abertura do browser.
● Para obter permissão de acesso à internet, deve-se adicionar a seguinte 
linha no arquivo AndroidManifest.xml:
<uses-permission android:name=”android.permission.INTERNET”/>
brunolopesjn@gmail.com
10/12/11
75Faculdade 
7 de Setembro
Intent
public class MainActivity extends Activity{
@Override
 
 public void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.main); 
 Uri uri = Uri.parse("http://www.google.com");
 Intent intent = new Intent(Intent.ACTION_VIEW, uri);
 startActivity(intent);
 }
}
brunolopesjn@gmail.com
10/12/11
76Faculdade 
7 de Setembro
Realizando uma 
chamada telefônica
brunolopesjn@gmail.com
10/12/11
77Faculdade 
7 de Setembro
Realizando uma chamada 
telefônica
● Talvez seja necessário automatizar a ligação para um outro 
telefone.
● Para isto basta criar uma Intent, com a ação 
Intent.ACTION_CALL e informar o número do telefone 
desejado.
● Para obter a permissão para realizar uma ligação telefônica, 
deve-se adicionar a seguinte linha no arquivo 
AndroidManifest.xml:
<uses-permission android:name=”android.permission.CALL_PHONE />
brunolopesjn@gmail.com
10/12/11
78Faculdade 
7 de Setembro
Realizando uma chamada 
telefônica
public class MainActivity extends Activity{
@Override
 
 public void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.main); 
 Uri uri = Uri.parse("tel:11223344");
 Intent intent = new Intent(Intent.ACTION_CALL, uri);
 startActivity(intent);
 }
}
brunolopesjn@gmail.com
10/12/11
79Faculdade 
7 de Setembro
Visualizar um 
contato da 
agenda
brunolopesjn@gmail.com
10/12/11
80Faculdade 
7 de Setembro
Visualizar um contato da 
agenda
● Digamos que uma aplicação necessite exibir informações sobre 
um determinado contato cadastrado na agenda.
● Para tanto a ação Intent.ACTION_VIEW pode ser utilizada 
para exibir o contato desejado.
● O padrão para identificar o contato é: 
content://com.android.contacts/contacts/1
● O número 1 no final do padrão acima representa o id do 
contato que deve ser visualizado.
● Para obter permissão para ler os contatos da agenda, deve-se 
adicionar a seguinte linha no arquivo AndroidManifest.xml:
<uses-permission android:name=”android.permission.READ_CONTACTS” />
brunolopesjn@gmail.com
10/12/11
81Faculdade 
7 de Setembro
Visualizar um contato da 
agenda
public class MainActivity extends Activity{
@Override
 
 public void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.main);
 
 Uri uri = 
Uri.parse("content://com.android.contacts/contacts/1");
 Intent intent = new Intent(Intent.ACTION_VIEW, uri);
 startActivity(intent);
 }
}
brunolopesjn@gmail.com
10/12/11
82Faculdade 
7 de Setembro
Visualizar todos os 
contatos da agenda
brunolopesjn@gmail.com
10/12/11
83Faculdade 
7 de Setembro
Visualizar todos os 
contatos da agenda
● Para visualizar todos os contatos da agenda, utilizaremos a 
ação Intent.ACTION_PICK.
● Esta ação exibe a lista de contatos, permitindo que o usuário 
selecione algum contato.
● A mesma permissão requisitada no exemplo anterior (visualizar 
um único contato da agenda) é a mesma utilizada neste 
exemplo.
● Caso for utilizado o método startActivityForResult(Intent, int), a 
URI do contatoselecionado será encaminhada como resposta 
para a activity que invocou.
brunolopesjn@gmail.com
10/12/11
84Faculdade 
7 de Setembro
Visualizando todos os 
contatos da agenda
public class MainActivity extends Activity{
@Override
 
 public void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.main); 
 Uri uri = 
Uri.parse("content://com.android.contacts/contacts/");
 Intent intent = new Intent(Intent.ACTION_PICK, uri);
 startActivity(intent);
 }
}
brunolopesjn@gmail.com
10/12/11
85Faculdade 
7 de Setembro
Exercícios
brunolopesjn@gmail.com
10/12/11
86Faculdade 
7 de Setembro
Exercícios
● Criar um projeto chamado Projeto03
● Implementar todos os exemplos de Intents
brunolopesjn@gmail.com
10/12/11
87Faculdade 
7 de Setembro
Interface Gráfica
Gerenciadores 
de Layout
brunolopesjn@gmail.com
10/12/11
88Faculdade 
7 de Setembro
Gerenciadores de Layout
● No Android existe diversos tipos de gerenciadores de layout.
● Alguns podem organizar os componentes na horizontal ou 
vertical.
● Outros podem controlar exatamente a sua posição através de 
coordenadas cartesianas (X e Y).
● Agora aprenderemos como organizar os componentes da tela 
com um gerenciador de layout.
brunolopesjn@gmail.com
10/12/11
89Faculdade 
7 de Setembro
Classe View
● A classe View é a classe mãe de todos os componentes visuais 
do Android.
● Cada subclasse de View deve implementar o método 
onDraw(Canvas), responsável por desenhar o componente na 
tela.
● Uma View geralmente é chamada de componente.
● Existe dois tipos de componentes:
● Widgets: que herdam diretamente da classe View (Button, 
ImageView e TextView).
● Gerenciadores de layout: que herdam diretamente da subclasse 
ViewGroup e são popularmente chamados de layouts.
brunolopesjn@gmail.com
10/12/11
90Faculdade 
7 de Setembro
ViewGroup
● A função de um gerenciador de layout é organizar a disposição 
dos componentes na tela automaticamente.
● Os principais gerenciadores de layout são:
● AbsoluteLayout: Permite posicionar os componentes a partir se suas 
coordenadas x e y.
● FrameLayout: O tipo mais comum e simples de layout, utilizado quando um 
componente precisa ocupar a tela inteira.
● LinearLayout: Utilizado para organizar os componentes na horizontal ou na 
vertical.
● TableLayout: É filho de LinearLayout e pode ser usado para dispor os 
componentes em uma tabela com linhas e colunas.
● RelativeLayout: Permite posicionar um componente relativo à outro, por 
exemplo, abaixo, acima, ou ao lado de um componente já existente.
brunolopesjn@gmail.com
10/12/11
91Faculdade 
7 de Setembro
ViewGroup
● Sempre que configurarmos um gerenciador de layout, devemos 
definir o valor da altura e largura do layout.
● Para especificar a largura e a altura, utilizamos os seguintes 
parâmetros:
● android:layout_width: Especifica a largura de um componente.
● android:layout_height: Especifica a altura de um componente.
● Esses dois parâmetros podem receber os seguintes valores:
● Número: número inteiro especificando o tamanho do componente, por exemplo, 
100px.
● fill_parent (match_parent): significa que o componente irá ocupar todo o 
espaço util definido pelo seu pai.
● wrap_content: o componente irá ocupar o tamanho necessário.
brunolopesjn@gmail.com
10/12/11
92Faculdade 
7 de Setembro
FrameLayout
brunolopesjn@gmail.com
10/12/11
93Faculdade 
7 de Setembro
FrameLayout
● A classe FrameLayout, é a mais simples de todos os 
gerenciadores de layout do Android.
● É utilizada quando a tela possui apenas um componente que 
pode preencher a tela inteira.
● Um componente inserido no FrameLayout SEMPRE será 
posicionado no canto superior esquerdo da tela.
● Pode ocupar a tela inteira ou não.
● É possível inserir mais de um componente no FrameLayout, 
mas sempre os últimos componentes inseridos ficarão na 
frente dos demais, seguindo o conceito de pilha.
brunolopesjn@gmail.com
10/12/11
94Faculdade 
7 de Setembro
FrameLayout
<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent">
 <ImageView
 android:layout_width="wrap_content"
 android:layout_height="wrap_content"
 android:src="@drawable/icon"/>
</FrameLayout>
brunolopesjn@gmail.com
10/12/11
95Faculdade 
7 de Setembro
LinearLayout
brunolopesjn@gmail.com
10/12/11
96Faculdade 
7 de Setembro
LinearLayout
● A classe LinearLayout é um dos gerenciadores de layout mais 
utilizados.
● É possível organizar os componentes na horizontal, ou na 
vertical.
● É possível utilizar a orientação do LinearLayout através do 
atributo android:orientation.
● Se o parâmetro android:orientation não for definido, por padrão 
o LinearLayout organiza os componentes na horizontal.
● Caso os componentes extrapolem a área útil da tela, os 
componentes que estiverem fora desta área não serão 
exibidos.
brunolopesjn@gmail.com
10/12/11
97Faculdade 
7 de Setembro
LinearLayout
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout 
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical">
 <ImageView
 android:layout_width="wrap_content"
 android:layout_height="wrap_content"
 android:src="@drawable/icon"/>
 <ImageView
 android:layout_width="wrap_content"
 android:layout_height="wrap_content"
 android:src="@drawable/icon"/>
</LinearLayout>
brunolopesjn@gmail.com
10/12/11
98Faculdade 
7 de Setembro
TableLayout
brunolopesjn@gmail.com
10/12/11
99Faculdade 
7 de Setembro
Table Layout
● A classe TableLayout é muito útil para construir formulários.
● Cada linha da tabela é formada por um TableRow, que é uma 
subclasse de LinearLayout.
● O TableLayout possui os seguintes atributos:
● android:stretchColumns: Faz com que as colunas especificadas 
ocupem o espaço disponível da tela, expandindo-as.
● android:shrinkColumns: Faz com que as colunas especificadas 
sejam sempre exibidas dentro da tela.
● Esses parâmetros recebem os índices das colunas, separados 
por virgula
● O índice das colunas inicia em zero (0).
brunolopesjn@gmail.com
10/12/11
100Faculdade 
7 de Setembro
TableLayout
<?xml version="1.0" encoding="utf-8"?>
<TableLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent">
 <TableRow>
 <ImageView
 android:layout_width="wrap_content"
 android:layout_height="wrap_content"
 android:src="@drawable/icon"/>
 <ImageView
 android:layout_width="wrap_content"
 android:layout_height="wrap_content"
 android:src="@drawable/icon"/>
 </TableRow>
</TableLayout>
brunolopesjn@gmail.com
10/12/11
101Faculdade 
7 de Setembro
RelativeLayout
brunolopesjn@gmail.com
10/12/11
102Faculdade 
7 de Setembro
RelativeLayout
● A classe RelativeLayout pode posicionar os componentes ao 
lado, abaixo, ou acima de um outro componente já existente.
● Para isso é necessário definir um id para cada componente.
● Como o posicionamento de um componente depende de um 
outro componente, o componente a ser referenciado DEVE 
aparecer antes no layout do arquivo XML.
● Os seguintes atributos podem ser usados para informar a 
posição de um componente:
● android:layout_below: posiciona abaixo do componente indicado.
● android:layout_above: posiciona acima do componente indicado.
● android:layout_toRightOf: posiciona a direita do componente indicado.brunolopesjn@gmail.com
10/12/11
103Faculdade 
7 de Setembro
RelativeLayout
● android:toLeftOf: posiciona a esquerda do componente indicado.
● android:layout_alingParentTop: alinha no topo do componente indicado.
● android:layout_alingParentBottom: alinha abaixo do componente indicado.
● android:layout_marginTop: define uma margem superior do componente.
● android:layout_marginLeft: define uma margem esquerda do componente.
● android:layout_marginRight: define uma margem direita do componente.
● android:layout_marginBottom: define uma margem inferior do componente
brunolopesjn@gmail.com
10/12/11
104Faculdade 
7 de Setembro
RelativeLayout
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent">
 <TextView
 android:layout_width="fill_parent"
 android:layout_height="wrap_content"
 android:id="@+id/label"/>
 <EditText
 android:layout_width="fill_parent"
 android:layout_height="wrap_content"
 android:layout_below="@+id/label"/>
</RelativeLayout>
brunolopesjn@gmail.com
10/12/11
105Faculdade 
7 de Setembro
AbsoluteLayout
brunolopesjn@gmail.com
10/12/11
106Faculdade 
7 de Setembro
AbsoluteLayout
● A classe AbsoluteLayout, permite controlar exatamente a 
posição dos componentes.
● Para isso, deve-se fornecer as coordenadas X e Y utilizando-se 
os atributos:
● android:layout_x: Define o valor da coordenada X do componente.
● android:layout_y: Define o valor da coordenada Y do componente.
● Deve-se ter cuidado com a utilização deste layout, pois os 
componentes podem ficar posicionados erroneamente em 
diferentes tipos de tela (display).
brunolopesjn@gmail.com
10/12/11
107Faculdade 
7 de Setembro
AbsoluteLayout
<?xml version="1.0" encoding="utf-8"?>
<AbsoluteLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent">
 <TextView
 android:layout_width="fill_parent"
 android:layout_height="wrap_content"
 android:layout_x="50px"
 android:layout_y="100px"/>
</AbsoluteLayout>
brunolopesjn@gmail.com
10/12/11
108Faculdade 
7 de Setembro
Interface Gráfica
Componentes 
Visuais
brunolopesjn@gmail.com
10/12/11
109Faculdade 
7 de Setembro
Definição de recursos de 
texto, cores e imagens
● A classe R de cada aplicação é o ponto centra de acesso aos 
recursos.
● Para acessar um arquivo xml de layout, basta utilizarmos a 
classe R da seguinte maneira: R.layout.nome_do_layout.xml.
● De forma similar, outros arquivos podem ser acessados através 
da classe R.
● Outros recursos como, por exemplo, texto, imagens e cores, 
podem ser referenciados através de arquivos xml.
● Por exemplo, quando criamos um projeto no eclipse, 
automaticamente é criado um arquivo /res/values/string.xml, 
que contem o nome da aplicação e uma mensagem de hello 
world.
brunolopesjn@gmail.com
10/12/11
110Faculdade 
7 de Setembro
Definição de recursos de 
texto, cores e imagens
<?xml version="1.0" encoding="utf-8"?>
<resources>
 <string name="hello">Hello World, MainActivity!</string>
 <string name="app_name">TreinamentoAndroid</string>
</resources>
brunolopesjn@gmail.com
10/12/11
111Faculdade 
7 de Setembro
Arquivo XML com textos
● É possível centralizar todas as mensagens da aplicação em um 
arquivo XML.
● O arquivo string.xml é criado automaticamente quando um 
projeto Android é criado.
● Também é possível criar seus próprios arquivos XML contendo 
mensagens personalizadas.
● O arquivo XML pode ter qualquer nome, com letras minusculas 
de a-z, 1-9 e o caractere underline (_).
● Dentro do arquivo, os dados devem estar dispostos da seguinte 
maneira.
brunolopesjn@gmail.com
10/12/11
112Faculdade 
7 de Setembro
Arquivo XML com textos
<?xml version="1.0" encoding="utf-8"?>
<resources>
 <string name="instrutor_nome">Bruno Lopes</string>
 <string name="instrutor_email">bruno@casic.com.br</string>
 <string name="instrutor_msn">brunolopesjn@gmail.com</string>
</resources>
brunolopesjn@gmail.com
10/12/11
113Faculdade 
7 de Setembro
Arquivo XML com cores
● Também é possível definir um arquivo XML com cores a serem 
utilizadas em nossas aplicações.
● O processo de criar um arquivo XML com cores é muito similar 
ao do arquivo XML com texto.
● Ao invés de utilizarmos a tag <string></string> no arquivos 
XML, usaremos a tag <color></color>.
● As cores devem estar no seguinte formato #RRGGBB.
brunolopesjn@gmail.com
10/12/11
114Faculdade 
7 de Setembro
Arquivo XML com cores
<?xml version="1.0" encoding="utf-8"?>
<resources>
 <color name="preto">#000000</color>
 <color name="branco">#FFFFFF</color>
 <color name="vermelho">#FF0000</color>
 <color name="verde">#00FF00</color>
 <color name="azul">#0000FF</color>
</resources>
brunolopesjn@gmail.com
10/12/11
115Faculdade 
7 de Setembro
Imagens
● As imagens são um precioso recurso em aplicações modernas.
● Elas devem ser armazenadas na pasta /res/drawable.
● Exitem três pastas drawable por padrão:
● drawable-hdpi: Imagens para dispositivos com tela (display) de 
alta definição.
● drawable-mdpi: Imagens para dispositivos com tela (display) 
com resolução mediana.
● drawable-ldpi: Imagens para dispositivos com tela (display) com 
baixa resolução.
brunolopesjn@gmail.com
10/12/11
116Faculdade 
7 de Setembro
Imagens
brunolopesjn@gmail.com
10/12/11
117Faculdade 
7 de Setembro
Imagens
brunolopesjn@gmail.com
10/12/11
118Faculdade 
7 de Setembro
Unidades de Medida
brunolopesjn@gmail.com
10/12/11
119Faculdade 
7 de Setembro
Unidades de Medida
● As unidades de medida utilizadas pelo Android sào:
● px(pixel): Corresponde ao número de pixels da tela.
● in(polegadas):Baseado no tamanho físico da tela.
● mm(milímetros): Baseado no tamanho da tela.
● pt(pontos): 1/72 de uma polegada, baseado no tamanho da tela 
física.
● dp (density-indenpendent pixels): Essa unidade é relativa a 
resolução da tela. Por exemplo, se a tela for de 160 dpi, significa 
que 1dp representa um pixel da tela de um total de 160.
● sp(scale-indenpendent pixels): igual ao anterior, mas também 
leva em consideração o tamanho da fonte que o usuário esta 
usando. É recomendado utilizar esta medida para tamanhos de 
fonte.
brunolopesjn@gmail.com
10/12/11
120Faculdade 
7 de Setembro
Componentes
brunolopesjn@gmail.com
10/12/11
121Faculdade 
7 de Setembro
Componentes
● Um componente é um objeto do tipo View, também chamado 
de Widget.
● O android provê um conjunto de widgtes, como botões, 
checkboxes, e campos de texto.
● Também existem widgets mais complexos como, por exemplo, 
relógio, controle de zoom e data picker.
● Também é possível criar os seus próprios componentes ou 
estender componentes existentes.
brunolopesjn@gmail.com
10/12/11
122Faculdade 
7 de Setembro
Componentes
Componente Listener
TextView
Edittext
AutoCompleteTextView
Button/ImageButton OnClickListener()
CheckBox/ToogleBox isChecked()*
RadioGroup/RadioButton OnCheckedChangeListener()
Spinner OnItemSelectedListener()
ProgressDialog
ProgressBar
Toast
* Método do próprio objeto
brunolopesjn@gmail.com
10/12/11
123Faculdade 
7 de Setembro
Toast
● A classe Toast é utilizada para exibir alertas para o usuário.
● Cada alerta pode ser visualizado na tela por um determinado 
tempo:
● Toast.LENGTH_SHORT
● Toast.LENGTH_LONG
● Um tempo pré-determinado (em milissegundos)
● Também é possível criar um alerta com uma interface mais 
complexa.
● Para tanto devemos passar uma instancia de um objetodo tipo 
View para o Toast.
brunolopesjn@gmail.com
10/12/11
124Faculdade 
7 de Setembro
Adicionando Menus na Aplicação
brunolopesjn@gmail.com
10/12/11
125Faculdade 
7 de Setembro
Adicionando Menus na 
Aplicação
● Para adicionarmos menus em uma tela de uma aplicação basta 
sobrescrever o método onCreateOptionsMenu(View) da classe 
Activity.
● Esse método é apenas chamado na primeira vez que a Activity 
é usada.
● Após adicionar os itens no menu é necessário retornar uma 
valor boolean, indicando se o menu deve ou não ser exibido.
● Os itens são sempre visualizados na ordem em que foram 
adicionados no menu.
brunolopesjn@gmail.com
10/12/11
126Faculdade 
7 de Setembro
Aplicando Menus na 
Aplicação
public static final int NOVO = 0; 
public static final int SALVAR = 1; 
public static final int EXCLUIR = 2;
@Override
 public boolean onCreateOptionsMenu(Menu menu) {
 
 super.onCreateOptionsMenu(menu);
 
 MenuItem item = menu.add(0, NOVO, 0, "Novo");
 item.setIcon(R.drawable.ic_launcher);
 item = menu.add(0, SALVAR, 0, "Salvar");
 item.setIcon(R.drawable.ic_launcher);
 item = menu.add(0, EXCLUIR, 0, "Excluir");
 item.setIcon(R.drawable.ic_launcher);
 
 return true;
 }
brunolopesjn@gmail.com
10/12/11
127Faculdade 
7 de Setembro
Adicionando Menus na 
Aplicação
@Override
 public boolean onMenuItemSelected(int featureId, MenuItem item) {
 
 super.onMenuItemSelected(featureId, item);
 
 switch (item.getItemId()) {
 case NOVO:
 Toast.makeText(this, "Clicou no menu Novo", Toast.LENGTH_SHORT).show();
 return true;
 case SALVAR:
 Toast.makeText(this, "Clicou no menu Salvar", Toast.LENGTH_SHORT).show();
 return true;
 case EXCLUIR:
 Toast.makeText(this, "Clicou no menu Excluir", Toast.LENGTH_SHORT).show();
 return true;
 }
 
 return false;
 
 }
brunolopesjn@gmail.com
10/12/11
128Faculdade 
7 de Setembro
Trabalhando com 
Submenus
● Para criar um submenu basta utilizar o método 
addSubMenu(texto) da classe Menu.
● O Android não permite adicionar um submenu a outro, de forma 
que apenas um nível de menus é permitido pela plataforma.
● Todas as outras considerações sobre a criação de menus e 
identificação pelos ids funcionam exatamente como explicado 
anteriormente.
brunolopesjn@gmail.com
10/12/11
129Faculdade 
7 de Setembro
Trabalhando com 
Submenus
 SubMenu submenu = menu.addSubMenu(0, OUTROS, 0, 
"Outros");
 submenu.setIcon(R.drawable.ic_launcher);
 item = submenu.add(0, PESQUISAR, 0, "Pesquisar");
 item.setIcon(R.drawable.ic_launcher);
 item = submenu.add(0, LIMPAR, 0, "Limpar");
 item.setIcon(R.drawable.ic_launcher);
 item = submenu.add(0, SAIR, 0, "Sair");
 item.setIcon(R.drawable.ic_launcher);
brunolopesjn@gmail.com
10/12/11
130Faculdade 
7 de Setembro
FIM
Email
brunolopesjn@gmail.com
Blog
kariridev.blogspot.com
brunolopesjn@gmail.com
10/12/11
131Faculdade 
7 de Setembro
OBRIGADO!
	Slide 1
	Slide 2
	Slide 3
	Slide 4
	Slide 5
	Slide 6
	Slide 7
	Slide 8
	Slide 9
	Slide 10
	Slide 11
	Slide 12
	Slide 13
	Slide 14
	Slide 15
	Slide 16
	Slide 17
	Slide 18
	Slide 19
	Slide 20
	Slide 21
	Slide 22
	Slide 23
	Slide 24
	Slide 25
	Slide 26
	Slide 27
	Slide 28
	Slide 29
	Slide 30
	Slide 31
	Slide 32
	Slide 33
	Slide 34
	Slide 35
	Slide 36
	Slide 37
	Slide 38
	Slide 39
	Slide 40
	Slide 41
	Slide 42
	Slide 43
	Slide 44
	Slide 45
	Slide 46
	Slide 47
	Slide 48
	Slide 49
	Slide 50
	Slide 51
	Slide 52
	Slide 53
	Slide 54
	Slide 55
	Slide 56
	Slide 57
	Slide 58
	Slide 59
	Slide 60
	Slide 61
	Slide 62
	Slide 63
	Slide 64
	Slide 65
	Slide 66
	Slide 67
	Slide 68
	Slide 69
	Slide 70
	Slide 71
	Slide 72
	Slide 73
	Slide 74
	Slide 75
	Slide 76
	Slide 77
	Slide 78
	Slide 79
	Slide 80
	Slide 81
	Slide 82
	Slide 83
	Slide 84
	Slide 85
	Slide 86
	Slide 87
	Slide 88
	Slide 89
	Slide 90
	Slide 91
	Slide 92
	Slide 93
	Slide 94
	Slide 95
	Slide 96
	Slide 97
	Slide 98
	Slide 99
	Slide 100
	Slide 101
	Slide 102
	Slide 103
	Slide 104
	Slide 105
	Slide 106
	Slide 107
	Slide 108
	Slide 109
	Slide 110
	Slide 111
	Slide 112
	Slide 113
	Slide 114
	Slide 115
	Slide 116
	Slide 117
	Slide 118
	Slide 119
	Slide 120
	Slide 121
	Slide 122
	Slide 123
	Slide 124
	Slide 125
	Slide 126
	Slide 127
	Slide 128
	Slide 129
	Slide 130
	Slide 131