CURSO ANDROID MÓDULO BÁSICO
Faculdade 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.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 2
Who are you?
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 3
Cronograma ●
Apresentando o Android
●
Conceitos básicos
●
Activity
●
Intent
●
Interface Gráfica Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 4
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, sintase livre para expor.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 5
Dicas E a dica mais importante!
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 6
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!
+ Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 7
APRESENTANDO O ANDROID
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 8
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!!!
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 9
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.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 10
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.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 11
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.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 12
Então, se não existe uma máquina virtual Java, como o código Java feito para o Android funciona???
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 13
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.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 14
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).
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 15
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. Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 16
Qual é o endereço do seu blog? Qual é o seu endereço de e-mail?
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 17
CONTATOS
BLOG http://kariridev.blogspot.com
E-MAIL brunolopesjn@gmail.com
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 18
CONCEITOS BĂ SICOS
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 19
Activity
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 20
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.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 21
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); } }
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 22
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. Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 23
Layout
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 24
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.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 25
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>
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 26
AndroidManifest.xml
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 27
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
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 28
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>
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 29
A classe R
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 30
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.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 31
Como irei obter uma referĂŞncia do objeto View criado a partir de um XML???
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 32
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. Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 33
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; } }
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 34
Acessando elementos visuais
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 35
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.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 36
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); } }
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 37
Tratamento de eventos
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 38
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. Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 39
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. } }
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 40
LogCat
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 41
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. Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 42
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"); } }
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 43
ExercĂcios
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 44
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(). Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 45
ACTIVITY
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 46
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.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 47
Ciclo de vida da Activity
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 48
Ciclo de vida da Activity
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 49
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.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 50
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. Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 51
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.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 52
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. Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 53
Navegando entre Activities
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 54
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. Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 55
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.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 56
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); }
}
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 57
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.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 58
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 } } } Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 59
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.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 60
Passagem de par창metro entre Activities
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 61
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.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 62
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); }
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 63
Passagem de parâmetros entre 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.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 64
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.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 65
ExercĂcios
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 66
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. Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 67
INTENT
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 68
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.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 69
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.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 70
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?
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 71
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.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 72
Abrindo o Browser
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 73
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”/>
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 74
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); } } Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 75
Realizando uma chamada telef么nica
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 76
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 />
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 77
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); } } Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 78
Visualizar um contato da agenda
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 79
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” />
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 80
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);
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 81
Visualizar todos os contatos da agenda
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 82
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 contato selecionado será encaminhada como resposta para a activity que invocou.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 83
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); } }
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 84
ExercĂcios
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 85
Exercícios ●
Criar um projeto chamado Projeto03
●
Implementar todos os exemplos de Intents
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 86
Interface Grรกfica Gerenciadores de Layout
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 87
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.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 88
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.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 89
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.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 90
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.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 91
FrameLayout
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 92
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.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 93
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>
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 94
LinearLayout
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 95
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.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 96
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> Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 97
TableLayout
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 98
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). Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 99
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>
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 100
RelativeLayout
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 101
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.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 102
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
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 103
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>
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 104
AbsoluteLayout
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 105
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).
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 106
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>
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 107
Interface Grรกfica Componentes Visuais
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 108
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. Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 109
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>
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 110
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.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 111
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>
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 112
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.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 113
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>
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 114
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.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 115
Imagens
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 116
Imagens
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 117
Unidades de Medida
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 118
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. Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 119
Componentes
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 120
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.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 121
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
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 122
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 objeto do tipo View para o Toast.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 123
Adicionando Menus na Aplicação
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 124
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.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 125
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; Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 126
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; }
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 127
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.
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 128
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);
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 129
FIM
Email brunolopesjn@gmail.com Blog kariridev.blogspot.com
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 130
OBRIGADO!
Faculdade 7 de Setembro
brunolopesjn@gmail.com
10/12/11 131