Introdução ao Android

Introdução ao Android Átila Camurça Alves 1 Edição 17 de maio de 2012

2

Sumário 1 Preparando o Ambiente de Desenvolvimento 7 1.1 Introdução..................................... 7 1.2 Instalação..................................... 7 1.2.1 Java JDK 6................................ 8 1.2.2 Android SDK.............................. 8 1.2.3 Android 2.2 API 8............................ 9 1.2.4 Android Virtual Device (AVD)..................... 9 1.2.5 Eclipse Indigo............................... 9 1.2.6 Plugin ADT................................ 10 2 Exemplo prático 11 2.1 Primeira aplicação - Contatos.......................... 11 2.1.1 AndroidManifest.xml........................... 11 2.1.2 Activity.................................. 12 2.1.3 Formulários................................ 14 2.1.4 Construindo o Model da aplicação................... 16 2.1.5 Mostrando os dados na View...................... 20 2.1.6 Editando dados existentes........................ 24 3 Livro de Receitas 29 3.1 Mostrando Diálogos............................... 29 3.1.1 Editar/Excluir ao clicar e segurar na ListView............ 29 3.1.2 Diálogo de confirmação......................... 31 3.1.3 Entrada de diferentes tipos de dados.................. 33 3.1.4 Validação de dados............................ 34 3.1.5 Fazendo uma ligação........................... 35 3.1.6 Enviando e-mail............................. 37 3.2 Internacionalização (i18n)............................ 39 3.2.1 Forçando região para teste........................ 39 4 Sobre o Autor 41 4.1 Sugestões e Críticas............................... 41 3

4 SUMÁRIO

Lista de Códigos-fonte 1 Projeto inicial [AndroidManifest.xml]...................... 11 2 Layout principal [res/layout/main.xml]..................... 12 3 Menu principal [res/menu/main menu.xml].................. 12 4 Definir layout [MainActivity.java]........................ 13 5 Criando o menu [MainActivity.java]....................... 14 6 Formulário principal [res/layout/salvar.xml].................. 15 7 Mudando de Activity [MainActivity.java].................... 16 8 Utilizando EditText s [SalvarActivity.java]................... 16 9 Mapear SalvarActivity [AndroidManifest.xml]................. 16 10 Model da aplicação [Contato.java]....................... 17 11 Helper da aplicação [ContatoHelper.java].................... 18 12 Criar novo contato [ContatoHelper.java].................... 18 13 Fim da iteração criar contato [SalvarActivity.java].............. 19 14 Layout para cada linha da lista [res/layout/linha.xml]............ 21 15 Listar contatos existentes [ContatoHelper.java]................ 22 16 Classe Holder [MainActivity.java]........................ 22 17 Classe Adapter [MainActivity.java]....................... 23 18 Popular ListView [MainActivity.java]...................... 24 19 Passagem de parâmetros [MainActivity.java].................. 25 20 Ler e atualizar dados existentes [ContatoHelper.java]............. 26 21 Usando Activity para criar ou atualizar [SalvarActivity.java]......... 27 22 Deletar dados existentes [ContatoHelper.java]................. 29 23 Adicionar Listener para click longo [MainActivity.java]............ 30 24 Diálogo de confirmação ao deletar contato [MainActivity.java]........ 32 25 Distinção de dados [res/layout/salvar.xml]................... 34 26 Validação dos dados [SalvarActivity.java].................... 35 27 Permissão de realizar chamadas [AndroidManifest.xml]............ 36 28 Item chamar no diálogo [MainActivity.java].................. 37 29 Item enviar e-mail no diálogo [MainActivity.java]............... 38 30 Forçando região [SalvarActivity.java]...................... 39 5

6 LISTA DE CÓDIGOS-FONTE

Capítulo 1 Preparando o Ambiente de Desenvolvimento 1.1 Introdução O desenvolvimento de aplicativos para a plataforma Android é feito na linguagem Java. Para esta apostila serão utilizados os seguintes aplicativos e bibliotecas: Ubuntu 10.04 Java JDK 6 Android SDK Android 2.2 API 8 Eclipse Indigo ADT Plugin Você pode estar se perguntando: "Por que utilizar essa configuração?". Bom, para começar um ambiente de desenvolvimento precisa ser estável, e para isso nada melhor que o http://releases.ubuntu.com/lucid/ (Ubuntu 10.04). A IDE Eclipse funciona independente do sistema operacional, então podemos utilizar a versão mais recente. O mesmo para o plugin ADT (Android Development Tools). Usaremos especificamente para os exemplos a seguir a versão 2.2 do Android. Essa API é uma ótima escolha inicial, pois é a mais utilizada pelos aparelhos mais simples que rodam Android. É claro que você poderá instalar outras versões e compilar seus aplicativos para tablets, etc. 1.2 Instalação Toda a instalação será baseada no Ubuntu 10.04. Isso quer dizer que alguns passos podem ou não funcionar em outras distribuições. Nada que uma busca na internet não possa lhe ajudar. 7

8 CAPÍTULO 1. PREPARANDO O AMBIENTE DE DESENVOLVIMENTO 1.2.1 Java JDK 6 A instalação do Java no Ubuntu 10.04 é bastante simples. Você apenas irá precisar habilitar repositório de terceiros, ou Partner. Isso pode ser feito através do aplicativo Synaptic. No menu principal do Ubuntu clique em Sistema Administração Gerenciador de pacotes Synaptic. No menu do Synaptic clique em Configuração Repositórios. Na aba Outro Software temos vários itens que representam repositórios. Marque os dois repositórios que terminam com partner. Feche e depois clique em Editar Recarregar informações dos pacotes ou simplesmente Ctrl + R. Após a atualização dos pacotes existentes nos repositórios já é possível encontrar o Java JDK 6. No campo de Pesquisa rápida digite: sun-java6. Clique com botão direito no pacote sun-java6-jdk e selecione a opção Marcar para instalação. Depois basta Aplicar as mudanças. Para isso clique em Editar Aplicar as alterações marcadas ou Ctrl + P. Segundo a página de Requerimentos do Sistema (http://developer.android.com/ sdk/requirements.html) do site oficial do Android, é necessário uso do Java 6. Caso você queira utilizar o Java 7, você terá que configurar seu projeto Android para ser compilado com suporte a versão 6. 1.2.2 Android SDK Para o Android SDK comece pelo download http://developer.android.com/sdk/index. html. A instalação é feita apenas colocando o SDK em um diretório do sistema. Existem 2 bons locais para abrigar bibliotecas no Linux, são elas: /opt e /usr/local/lib. Nesse exemplo vamos utilizar este último. Abra um terminal e vamos aos comandos. Se você baixou o SDK para seu diretório Downloads, proceda da seguinte maneira: $ cd /home/usuario/downloads $ tar -xf android-sdk r18-linux.tgz $ sudo su # mv android-sdk-linux /usr/local/lib # cd /usr/local/lib # ln -s android-sdk-linux android-sdk # cd android-sdk/tools # ln -s android /usr/local/bin/android Obs.: troque usuario na primeira linha pelo seu login do sistema. Um pouco de Linux Para quem não está familiarizado com o ambiente Linux vamos a uma pequena explicação. Nos comandos acima aparecem dois caracteres que não devem ser escritos mas que representam algo importante no âmbito dos comandos, são eles $ e #. Estes caracteres indicam qual o nível do usuário; $ significa usuário comum, # representa super usuário (root). No comando sudo su é onde trocamos de usuário comum para super usuário. Neste momento você terá que entrar com sua senha de login.

1.2. INSTALAÇÃO 9 Dê atenção ao uso do comando ln. Ele é responsável por criar links simbólicos. Isso é muito útil quando se instala um aplicativo ou biblioteca, pois proporciona atualização sem que outros ajustes sejam feitos. Neste caso basta linkar outra vez e pronto. Note que no último comando temos um link simbólico para o diretório /usr/local/bin. É nele que colocamos os executáveis globais, ou seja, que são vistos a partir de qualquer outro diretório. Agora saindo do modo root e usando seu próprio usuário instalaremos a API. 1.2.3 Android 2.2 API 8 Ainda no terminal, agora como usuário comum, vamos abrir o aplicativo que instala qualquer uma das API disponibilizadas pelo Android. $ android O aplicativo Android SDK and AVD Manager irá aparecer. Clique em Avaliable packages e procure pela versão 2.2 API 8 do Android. Selecione e clique em Install Selected. Após o download você pode verificar a versão instalada em Installed packages, um dos itens é algo como SDK Plataform Android 2.2, API 8, revision 2. Se você quiser aproveite para baixar outras versões para utilizar em projetos futuros. 1.2.4 Android Virtual Device (AVD) Vamos aproveitar e criar nosso AVD para testar pela primeira vez nosso emulador. Ainda no Android SDK and AVD Manager clique em Virtual devices, depois em New... Dê um nome. Você pode usar qualquer nomenclatura, mas é interessante que tenha algo haver com a versão. Assim, caso você tenha que testar seu código em outras versões você poderá saber qual emulador utilizar. Por exemplo use android-2.2. Em Target escolha a versão, neste caso Android 2.2 - API Level 8. Pronto, apenas clique em Create AVD. Em relação as outras opções esteja a vontade para modificá-las. Provavelmente uma delas você terá que modificar, a Skin. Ele indica qual a resolução da tela do aparelho. Como não é possível redimensionar a janela, em alguns monitores a janela fica maior que a tela do seu monitor. 1.2.5 Eclipse Indigo A IDE Eclipse pode ser encontrada em http://www.eclipse.org/downloads/. Para o desenvolvimento de aplicativos para o Android a versão Eclipse IDE for Java Developers é ideal. Mas se você tiver interesse em aplicativos Java para Web a opção é baixar a versão Eclipse IDE for Java EE Developers. Em todo caso as duas vão servir para o desenvolvimento, pois ambas vem com suporte a Java. O Eclipse não possui instalador, no caso ele já vem pré-compilado. Basta apenas descompactar e executar o arquivo eclipse. Para sua comodidade você pode adicionar o Eclipse no menu do Ubuntu. Isso pode ser feito apenas clicando com o botão direiro do mouse no menu principal e escolhendo a opção Editar menus. Ou você pode usar a dica do blog MAD3 Linux

10 CAPÍTULO 1. PREPARANDO O AMBIENTE DE DESENVOLVIMENTO (http://www.mad3linux.org) - http://va.mu/vsgr. adicionar um item ao menu visível a todos os usuários. Essa dica irá lhe mostrar como 1.2.6 Plugin ADT Para a instalação do plugin ADT vamos abrir o Eclipse, e em seu menu selecione Help Install New Software... Depois cliquem em Add do lado direito superior. A janela Add Repository aparecerá, agora basta digitar ADT Plugin em Name e a url https://dl-ssl.google.com/android/ eclipse/ em Location. Clique em Ok. Verifique se o campo Work with está apontando para o plugin ADT. Caso positivo espere até que o Eclipse baixe os dados referentes a instalação do mesmo. Daí, basta marcar a opção Developer Tools e clicar em Next. O Eclipse irá pedir confirmação sobre os itens a serem instalados, clique novamente em Next. Agora basta aceitar os termos de uso e clicar em Finish. Após o download e a instalação, reinicie o Eclipse. Configurando o ADT Agora que o plugin foi instalado temos que dizer ao Eclipse onde nós instalamos o Android SDK. Isso pode ser feito clicando no menu Window Preferences. Selecione Android no painel lateral esquerdo. Em SDK Location clique em Browse... e indique o diretório do SDK, caso não lembre, ele está em /usr/local/lib/android-sdk. Clique em Apply na parte inferior direita para atualizar a lista de API s disponíveis. Caso você tenha mais dúvidas dê uma olhada na página oficial de instalação do plugin ADT localizada em http://developer.android.com/sdk/eclipse-adt.html. Testando o ADT Para testar o Android Development Tools ou ADT crie um projeto Android. No menu do Eclipse selecione File New Project... Selecione Android Project e clique em Next. Digite o nome do seu projeto e clique em Next. Neste ponto temos que escolher qual a plataforma que nosso projeto será criado. Como foi decidido antes usaremos a versão 2.2 API 8. Caso você tenha baixado outras API s certifique-se de que a versão está correta. Agora precisamos dizer o nome da aplicação, ou seja, o nome que será visível ao usuário. O nome do pacote você pode usar a nomenclatura nome aplicativo.app. Depois ele pergunta se você deseja criar sua primeira Activity, caso positivo dê um nome a ela, por exemplo MainActivity. E por último vem a versão mínima do SDK, neste caso já está configurada como 8. Basta clicar em Finish. Após isso clique com botão direito do mouse no projeto recem criado, e Run As Android Application. Se tudo tiver dado certo é possível ver no emulador sua primeira aplicação rodando. Dica: uma vez que você abriu o emulador não o feche. Você irá notar que ao abrir pela primeira vez ele leva um tempo para isso. Neste caso ao atualizar o código-fonte apenas rode o aplicativo novamente. O plugin ADT fará com que o aplicativo seja reinstalado no emulador.

Capítulo 2 Exemplo prático 2.1 Primeira aplicação - Contatos Crie uma nova aplicação chamada Contatos. Para o nome do pacote use contatos.app. Chame a Activity de MainActivity, que será responsável pela Atividade Principal. Depois configure a plataforma Android a ser utilizada e Finish (em caso de dúvida verifique o item 1.2.6 Testando o ADT). Essa pode não ser uma aplicação muito útil, mas com ela poderemos aprender como funciona o Android. Você só poderá criar algo se você souber utilizar as ferramentas. 2.1.1 AndroidManifest.xml Esse é o arquivo que define nossa aplicação, mapeia as Activity s, entre outras configurações. Ao finalizar a criação do projeto, inicialmente este arquivo deverá conter o seguinte conteúdo: 1 <?xml version="1.0" encoding="utf-8"?> 2 <manifest xmlns:android= "http://schemas.android.com/apk/res/android" 3 package= "app.contatos" 4 android:versioncode= "1" 5 android:versionname= "1.0" > 6 <uses-sdk android:minsdkversion= "8" /> 7 <application android:icon= "@drawable/icon" android:label= "@string/app_name" > 8 <activity android:name= ".MainActivity" android:label= "@string/app_name" > 9 <intent-filter> 10 <action android:name= "android.intent.action.main" /> 11 <category android:name= "android.intent.category.launcher" /> 12 </intent-filter> 13 </activity> 14 </application> 15 </manifest> Código-fonte 1: Projeto inicial [AndroidManifest.xml] 11

12 CAPÍTULO 2. EXEMPLO PRÁTICO 2.1.2 Activity Não existe método main visível ao programador no Android. Ao invés disso temos Activity s. Para nossa primeira Activity criaremos uma lista de contatos e um menu para criação de novo contato. Para construir o layout inicial de nossa aplicação precisamos editar o arquivo main.xml localizado em res/layout. 1 <?xml version="1.0" encoding="utf-8"?> 2 <LinearLayout xmlns:android= "http://schemas.android.com/apk/res/android" 3 android:orientation= "vertical" 4 android:layout_width= "fill_parent" 5 android:layout_height= "fill_parent" > 6 <ListView 7 android:id= "@+id/contatos" 8 android:layout_width= "fill_parent" 9 android:layout_height= "wrap_content" /> 10 </LinearLayout> Código-fonte 2: Layout principal [res/layout/main.xml] Deste momento em diante tenha em mente que os arquivos xml aqui descritos são apenas para você poder comparar e ver se não esqueceu nada. Todos os layout s devem ser criados usando a ferramenta ADT. Você irá notar que ao abrir o xml uma janela de layout aparecerá. Para visualizar o xml ou o layout gráfico basta utilizar a aba inferior esquerda. Por fim, temos o menu. Clique com o botão direito do mouse em seu projeto e New Other... ou Ctrl + N. Procure por Android XML File. Em Resource Type escolha a opção Menu. Chame-o de main menu.xml. 1 <?xml version="1.0" encoding="utf-8"?> 2 <menu xmlns:android= "http://schemas.android.com/apk/res/android" > 3 <item 4 android:id= "@+id/add" 5 android:title= "Novo" 6 android:icon= "@android:drawable/ic_menu_add" /> 7 </menu> Código-fonte 3: Menu principal [res/menu/main menu.xml] Pronto, já temos nosso layout. Compile o projeto e vamos a próxima iteração. Convenção de nomes para ícones Observe que o ícone utilizado no menu vem junto com o SDK do Android. Você pode visualizar os ícones em SDK INSTALL/plataforms/android-8/data/res/drawable-hdpi (substitua SDK INSTALL pelo diretório de instalação do SDK do Android, no nosso caso

2.1. PRIMEIRA APLICAÇÃO - CONTATOS 13 usr/local/lib/android-sdk, 1.2.2). Note que há namespaces ou prefixos em cada um dos ícones. O Android recomenda a seguinte convenção: Tipo de Recurso Prefixo Exemplo Ícones Launcher icons Menu e Action Bar Status bar icons Tab icons Dialog icons ic ic launcher ic menu ic stat notify ic tab ic dialog ic adicionar.png ic launcher calendario.png ic menu ajuda.png ic stat notify msg.png ic tab recente.png ic dialog info.png Tabela 2.1: Convenção para nome dos ícones Note que você não é obrigado a utilizar os prefixos citados acima, isto é apenas uma convenção. Veja mais detalhes em http://developer.android.com/guide/practices/ ui_guidelines/icon_design.html. Abra o arquivo MainActivity.java e vá ao método oncreate. Defina o layout como sendo nosso main.xml. Para isso adicione o layout main ao final do método: 1 @Override 2 public void oncreate(bundle icicle) { 3 super.oncreate(icicle); 4 setcontentview(r.layout.main); 5 } Código-fonte 4: Definir layout [MainActivity.java] Cuidado: no ambiente Android temos uma classe chamada R. Ela existe tanto na biblioteca do Android como em cada projeto. Nesse caso faça o import da classe contatos.app.r. A classe android.r é utilizada em outras situações, onde códigos pré-prontos foram disponibilizados pela equipe do Android. Agora precisamos sobrescrever os métodos oncreateoptionsmenu e onoptionsitemselected. Eles irão criar o menu a partir de nosso layout e notificar quando os itens do menu forem pressionados, respectivamente. Vamos ao código:

14 CAPÍTULO 2. EXEMPLO PRÁTICO 1 @Override 2 public boolean oncreateoptionsmenu(menu menu) { 3 new MenuInflater(this).inflate(R.menu.main_menu, menu); 4 return super.oncreateoptionsmenu(menu); 5 } 6 7 @Override 8 public boolean onoptionsitemselected(menuitem item) { 9 if (item.getitemid() == R.id.add) { 10 irparasalvar(); 11 return true; 12 } 13 return super.onoptionsitemselected(item); 14 } 15 16 public void irparasalvar() { 17 // não implementado ainda... 18 } Código-fonte 5: Criando o menu [MainActivity.java] 2.1.3 Formulários Agora vamos criar nosso formulário para criação e edição de contatos. Começaremos pelo layout. Crie um arquivo xml em res/layout chamado salvar.xml.

2.1. PRIMEIRA APLICAÇÃO - CONTATOS 15 1 <?xml version="1.0" encoding="utf-8"?> 2 <RelativeLayout 3 android:id= "@+id/widget31" 4 android:layout_width= "fill_parent" 5 android:layout_height= "fill_parent" 6 xmlns:android= "http://schemas.android.com/apk/res/android" > 7 <TableLayout 8 android:id= "@+id/widget32" 9 android:layout_width= "fill_parent" 10 android:layout_height= "wrap_content" 11 android:orientation= "vertical" 12 android:stretchcolumns= "1" > 13 <TableRow 14 android:id= "@+id/widget33" 15 android:layout_width= "fill_parent" 16 android:layout_height= "wrap_content" 17 android:orientation= "horizontal" > 18 <TextView 19 android:id= "@+id/tvnome" 20 android:layout_width= "wrap_content" 21 android:layout_height= "wrap_content" 22 android:text= "Nome" ></TextView> 23 <EditText 24 android:id= "@+id/etnome" 25 android:layout_width= "wrap_content" 26 android:layout_height= "wrap_content" ></EditText> 27 </TableRow> 28 <!-- faça mais duas TableRow s contendo o Telefone e E-mail --> 29 <Button 30 android:id= "@+id/btsalvar" 31 android:text= "Salvar" 32 android:layout_height= "wrap_content" 33 android:layout_width= "fill_parent" ></Button> 34 </TableLayout> 35 </RelativeLayout> Código-fonte 6: Formulário principal [res/layout/salvar.xml] Crie uma nova Activity chamada SalvarActivity. Aproveite para implementar o método irparasalvar da classe MainActivity da seguinte maneira:

16 CAPÍTULO 2. EXEMPLO PRÁTICO 1 public void irparasalvar() { 2 Intent intent = new Intent(MainActivity.this, SaveActivity.class); 3 startactivity(intent); 4 } Código-fonte 7: Mudando de Activity [MainActivity.java] Veremos agora como manipular EditText s, que representam os campos de entrada de dados. Abra o SalvarActivity e adicione o método carregar e crie atributos para guardar os EditText s: 1 private EditText etnome, etfone, etemail; 2 /*... */ 3 4 @Override 5 public void oncreate(bundle icicle) { 6 super.oncreate(icicle); 7 setcontentview(r.layout.save); 8 carregar(); 9 } 10 11 public void carregar() { 12 etnome = (EditText) findviewbyid(r.id.etnome); 13 etfone = (EditText) findviewbyid(r.id.etfone); 14 etemail = (EditText) findviewbyid(r.id.etemail); 15 } Código-fonte 8: Utilizando EditText s [SalvarActivity.java] Para que a Activity funcione precisamos mapeá-la no arquivo AndroidManifest.xml. Adicione o conteúdo abaixo entre as tags application: 1 <activity android:name= ".SalvarActivity" ></activity> Código-fonte 9: Mapear SalvarActivity [AndroidManifest.xml] Utilize sempre o ADT e apenas confira se o arquivo está da maneira correta. 2.1.4 Construindo o Model da aplicação Criaremos nosso modelo da seguinte maneira:

2.1. PRIMEIRA APLICAÇÃO - CONTATOS 17 1 package app.contatos; 2 3 public class Contato { 4 private String nome, fone, email; 5 6 public String getemail() { 7 return email; 8 } 9 10 public void setemail(string email) { 11 this.email = email; 12 } 13 14 public String getfone() { 15 return fone; 16 } 17 18 public void setfone(string fone) { 19 this.fone = fone; 20 } 21 22 public String getnome() { 23 return nome; 24 } 25 26 public void setnome(string nome) { 27 this.nome = nome; 28 } 29 } Código-fonte 10: Model da aplicação [Contato.java] Agora precisamos de um helper. Ela nos ajudará a acessar o banco de dados. Crie uma classe chamada ContatoHelper que extende de SQLiteOpenHelper.

18 CAPÍTULO 2. EXEMPLO PRÁTICO 1 package app.contatos; 2 3 import android.content.context; 4 import android.database.sqlite.sqlitedatabase; 5 import android.database.sqlite.sqliteopenhelper; 6 7 public class ContatoHelper extends SQLiteOpenHelper { 8 9 private static final String DATABASE_NAME = "contatos.db" ; 10 private static final int VERSION = 1; 11 12 public ContatoHelper(Context context) { 13 super(context, DATABASE_NAME, null, VERSION); 14 } 15 16 @Override 17 public void oncreate(sqlitedatabase db) { 18 db.execsql( "CREATE TABLE contato (_id INTEGER PRIMARY KEY AUTOINCREMENT," 19 + " nome TEXT, fone TEXT, email TEXT);" ); 20 } 21 22 @Override 23 public void onupgrade(sqlitedatabase db, int oldversion, int newversion) { 24 // nada a fazer por enquanto... 25 } 26 } Código-fonte 11: Helper da aplicação [ContatoHelper.java] Para a iteração de criação de um novo contato, ainda em ContatoHelper vamos adicionar um método criar. Faça: 1 public void criar(contato contato) { 2 ContentValues cv = new ContentValues(); 3 4 cv.put( "nome", contato.getnome()); 5 cv.put( "fone", contato.getfone()); 6 cv.put( "email", contato.getemail()); 7 8 getwritabledatabase().insert( "contato", "fone", cv); 9 } Código-fonte 12: Criar novo contato [ContatoHelper.java] Agora temos que fazer a chamada do método criar da classe ContatoHelper em SalvarActivity. Para isso temos que criar uma instância de ContatoHelper, adicionar o botão salvar e adicionar um Listener de click (faça o import da classe

2.1. PRIMEIRA APLICAÇÃO - CONTATOS 19 android.view.view.onclicklistener). Vamos ao código: 1 /*... */ 2 private ContatoHelper helper; 3 private Button btsalvar; 4 5 @Override 6 public void oncreate(bundle icicle) { 7 /*... */ 8 helper = new ContatoHelper(this); 9 carregar(); 10 ir(); 11 /*... */ 12 } 13 14 public void carregar() { 15 /*... */ 16 btsalvar = (Button) findviewbyid(r.id.btsalvar); 17 } 18 19 public void ir() { 20 btsalvar.setonclicklistener(new OnClickListener() { 21 22 public void onclick(view view) { 23 Contato contato = new Contato(); 24 contato.setnome(etnome.gettext().tostring()); 25 contato.setfone(etfone.gettext().tostring()); 26 contato.setemail(etemail.gettext().tostring()); 27 helper.criar(contato); 28 finish(); 29 } 30 }); 31 } 32 33 @Override 34 protected void ondestroy() { 35 super.ondestroy(); 36 helper.close(); 37 } Código-fonte 13: Fim da iteração criar contato [SalvarActivity.java] Com essa implementação já é possível salvar contatos na base de dados.

20 CAPÍTULO 2. EXEMPLO PRÁTICO 2.1.5 Mostrando os dados na View Após salvar os dados no banco, devemos ser capazes de obter tais informações e colocálas em forma de Lista. Para isso criaremos um novo layout que será responsável por representar uma linha de nossa Lista. Essa linha deve ser semelhante a figura abaixo: Figura 2.1: Layout linha da Lista Para isso crie um arquivo chamado linha.xml em res/layout com o seguinte conteúdo.

2.1. PRIMEIRA APLICAÇÃO - CONTATOS 21 1 <?xml version="1.0" encoding="utf-8"?> 2 <LinearLayout xmlns:android= "http://schemas.android.com/apk/res/android" 3 android:layout_width= "fill_parent" 4 android:layout_height= "wrap_content" 5 android:orientation= "horizontal" > 6 <ImageView 7 android:id= "@+id/linha_icone" 8 android:layout_width= "wrap_content" 9 android:layout_height= "fill_parent" > 10 </ImageView> 11 <LinearLayout 12 android:layout_width= "fill_parent" 13 android:layout_height= "wrap_content" 14 android:orientation= "vertical" > 15 <TextView 16 android:id= "@+id/linha_nome" 17 android:layout_width= "fill_parent" 18 android:layout_height= "wrap_content" 19 android:textstyle= "bold" 20 android:ellipsize= "end" ></TextView> 21 <TextView 22 android:id= "@+id/linha_fone" 23 android:layout_width= "fill_parent" 24 android:layout_height= "wrap_content" ></TextView> 25 <TextView 26 android:id= "@+id/linha_email" 27 android:layout_width= "fill_parent" 28 android:layout_height= "wrap_content" ></TextView> 29 </LinearLayout> 30 </LinearLayout> Código-fonte 14: Layout para cada linha da lista [res/layout/linha.xml] Agora vamos até ContatoHelper e adicionar o método listar. E também adicionaremos métodos para facilitar obter os valores de cada atributo.

22 CAPÍTULO 2. EXEMPLO PRÁTICO 1 public Cursor listar() { 2 return getreadabledatabase() 3.rawQuery( "SELECT _id, nome, fone, email FROM contato ORDER BY nome", 4 null); 5 } 6 7 public String getnome(cursor c) { 8 return c.getstring(1); 9 } 10 11 public String getfone(cursor c) { 12 return c.getstring(2); 13 } 14 15 public String getemail(cursor c) { 16 return c.getstring(3); 17 } Código-fonte 15: Listar contatos existentes [ContatoHelper.java] Para popular cada linha de nossa Lista vamos criar uma classe interna (inner class) em MainActivity. Assim podemos fazer cache dos objetos aumentando a performance. Use o sufixo Holder para esse tipo de classe. 1 private static class ContatoHolder { 2 private TextView nome, fone, email = null; 3 4 public ContatoHolder(View linha) { 5 nome = (TextView) linha.findviewbyid(r.id.linha_nome); 6 fone = (TextView) linha.findviewbyid(r.id.linha_fone); 7 email = (TextView) linha.findviewbyid(r.id.linha_email); 8 } 9 10 public void popularform(cursor c, ContatoHelper helper) { 11 nome.settext(helper.getnome(c)); 12 fone.settext(helper.getfone(c)); 13 email.settext(helper.getemail(c)); 14 } 15 } Código-fonte 16: Classe Holder [MainActivity.java] Levando em conta que estamos usando a interface Cursor em nosso Helper temos que criar uma classe que extende de CursorAdapter que será responsável por definir o layout de cada linha da Lista. Crie uma classe interna chamada ContatoAdapter. Iremos sobrescrever dois métodos, newview() e bindview(), que são responsáveis por inflar (inflate) uma nova linha e reciclar uma linha existente, respectivamente.

2.1. PRIMEIRA APLICAÇÃO - CONTATOS 23 1 private ContatoHelper helper; 2 /*... */ 3 4 private class ContatoAdapter extends CursorAdapter { 5 6 public ContatoAdapter(Cursor c) { 7 super(mainactivity.this, c); 8 } 9 10 @Override 11 public View newview(context cntxt, Cursor cursor, ViewGroup vg) { 12 LayoutInflater inflater = getlayoutinflater(); 13 View linha = inflater.inflate(r.layout.linha, vg, false); 14 ContatoHolder holder = new ContatoHolder(linha); 15 linha.settag(holder); 16 return linha; 17 } 18 19 @Override 20 public void bindview(view view, Context cntxt, Cursor cursor) { 21 ContatoHolder holder = (ContatoHolder) view.gettag(); 22 holder.popularform(cursor, helper); 23 } 24 } Código-fonte 17: Classe Adapter [MainActivity.java] Com a introdução do Helper teremos que criar uma instância da classe Cursor para popular nossa ListView. Vamos ao código-fonte:

24 CAPÍTULO 2. EXEMPLO PRÁTICO 1 /*... */ 2 private Cursor model = null; 3 private ContatoAdapter adapter = null; 4 private ListView listview = null; 5 6 @Override 7 public void oncreate(bundle icicle) { 8 /*... */ 9 helper = new ContatoHelper(this); 10 carregar(); 11 } 12 13 public void carregar() { 14 listview = (ListView) findviewbyid(r.id.contatos); 15 model = helper.listar(); 16 startmanagingcursor(model); 17 adapter = new ContatoAdapter(model); 18 listview.setadapter(adapter); 19 } 20 21 @Override 22 protected void ondestroy() { 23 super.ondestroy(); 24 helper.close(); 25 } Código-fonte 18: Popular ListView [MainActivity.java] Nunca esquecendo de fechar o helper ao sair, pois assim garantimos que a conexão com o banco será fechada. 2.1.6 Editando dados existentes Para a edição de informações usaremos o mesmo Activity do criar, ou seja, SalvarActivity. Para isso precisamos passar um parâmetro para o Activity. Usaremos então um método do Intent que é responsável por isso, putextra(chave, valor). Para uma passagem de parâmetros segura devemos usar um namespace para que não colida com nenhum nome já utilizado pelo Android. Para isso criaremos uma variável estática do tipo String. Isso acontecerá quando o usuário segurar a linha que ele deseja editar. Podemos fazer isso utilizando a interface OnItemLongClickListener. Vamos incrementar também o método irparasalvar passando o parâmetro caso haja um. Vamos ao código:

2.1. PRIMEIRA APLICAÇÃO - CONTATOS 25 1 /*... */ 2 public static final String _ID = "app.contatos._id" ; 3 4 @Override 5 public void oncreate(bundle icicle) { 6 /*... */ 7 configurar(); 8 } 9 10 public void irparasalvar() { 11 irparasalvar(null); 12 } 13 14 public void irparasalvar(string id) { 15 Intent intent = new Intent(MainActivity.this, SalvarActivity.class); 16 if (id!= null) { 17 intent.putextra(_id, id); 18 } 19 startactivity(intent); 20 } 21 22 public void configurar() { 23 listview.setonitemclicklistener(new OnItemClickListener() { 24 public void onitemclick(adapterview<?> parent, View view, 25 int position, long id) { 26 irparasalvar(string.valueof(id)); 27 } 28 }); 29 } Código-fonte 19: Passagem de parâmetros [MainActivity.java] Agora é hora de tratar nosso parâmetro no SalvarActivity. Caso haja um parâmetro precisamos obter os dados existentes no banco de dados para então editá-lo. Neste caso precisaremos de mais dois métodos em ContatoHelper, que são ler e atualizar.