Mini Curso Introducao ao Google Android

Prévia do material em texto

Mini Curso Android 
 
 
 
 
 
Rodrigo Lopes Ferreira 
Sun Certified Enterprise Architect for Java EE 5 (II) 
Sun Certified Business Component Developer for Java EE 5 
Sun Certified Web Component Developer for Java EE 5 
Sun Certified Programmer for Java SE 5 
 
rodrigo.lopes.ferreira@hotmail.com 
 
www.discover.com.br 
 
Mini Curso de Android Página 1 
 
Tópicos Abordados: 
 
1) O que é Android 02 
2) O que é Android Development Tools (ADT) 04 
a. Instalando Eclipse Galileo com ADT Plugin 04 
3) O que é o Android SDK (Software Development Kit) 06 
a. Instalando o Android SDK e configurando as variáveis de ambiente 06 
4) Android Virtual Devices (AVD) 07 
a. Criando um novo AVD 07 
b. Executando o emulador do Android com acesso à internet 
(configurações de Proxy) 
09 
5) Configurando o Eclipse IDE para reconhecer o Android SDK 10 
6) Criando a primeira aplicação Android (Olá Mundo) 11 
7) Estrutura básica de uma aplicação Android 13 
a. O que é uma classe “Activity” 13 
b. Diretórios de recursos 13 
c. A classe “R.java” 14 
d. Navegador de Arquivos 14 
e. Tipos de arquivos do Android 15 
f. O arquivo “AndroidManifest.xml” 15 
g. Fazendo deploy da aplicação “Olá Mundo” para o emulador 16 
8) Utilizando os componentes visuais do Android 17 
9) Banco de Dados SQLite com Android 19 
10) Utilizando Google Maps com Android 22 
a. Obtendo a chave para acessar o serviço de mapas 22 
b. Construindo uma aplicação simples 24 
11) Referências e leituras recomendadas 27 
 
 
 
 
 
 
 
 
Mini Curso de Android Página 2 
 
Tópico 1 
O que é Android 
 
Hoje no mercado existem diversos sistemas 
operacionais diferentes para celulares e smartphones, o 
que causa falta de padronização e um enorme esforço ao 
tentar portar aplicações e utilização de recursos entre 
estes diferentes modelos e marcas. 
 Android é a resposta da Google para este 
problema. Trata-se de um sistema operacional open-
source baseado em Linux. Ele foi inicialmente 
desenvolvido pela Google e posteriormente pela Open 
Handset Alliance (uma associação comercial composta 
por mais de trinta empresas de tecnologia e telefonia celular, incluindo Google, HTC, 
Intel, Motorola, Qualcomm, Texas Instruments, Samsung, LG, T-Mobile, Nvidia e Wind 
River Systems, responsáveis por criar padrões abertos para os dispositivos móveis de 
todas as marcas participantes). O Android provavelmente irá tornar-se a plataforma 
dominante entre os smartphones nos próximos anos. 
Ele permite que os desenvolvedores criem software na linguagem de 
programação Java. Este software será totalmente compatível com todos os modelos 
que suportem a versão do Android para o qual ele foi desenvolvido, sem nenhuma 
mudança ou recompilação. 
 
Abaixo seguem as quatro características principais do Android: 
 
Aplicativos sem fronteiras 
Os aplicativos no Android podem acessar funcionalidades 
essenciais de dispositivos móveis por meio de APIs padrão. Os 
aplicativos podem anunciar seus recursos para que outros 
aplicativos os usem. 
 
Os aplicativos são criados igualmente 
Qualquer aplicativo do dispositivo móvel pode ser substituído 
ou estendido, mesmo componentes essenciais como o discador 
ou a tela inicial. 
 
Os aplicativos podem facilmente incorporar 
a web 
Mini Curso de Android Página 3 
 
Os aplicativos podem facilmente incorporar HTML, Java Script 
e páginas de estilo. Um aplicativo pode exibir conteúdo da web 
por meio de uma WebView. 
 
Os aplicativos podem ser executados em 
paralelo 
O Android é um ambiente multitarefa completo, no qual os 
aplicativos podem ser executados em paralelo. Um aplicativo 
pode produzir avisos para chamar a atenção enquanto estiver 
sendo executado em segundo plano. 
Quadro 1 – Características Principais do Android 
(fonte: http://code.google.com/intl/pt-BR/android/) 
 
A maior diferença entre Android e JME (Java Micro Edition), além dos recursos e 
de sua época, é claro, é que o Android não é uma aplicação que roda sobre o sistema 
operacional do dispositivo móvel; ele é o próprio sistema operacional, então, as 
aplicações desenvolvidas para o Android só rodam em dispositivos equipados com o 
sistema operacional Android, não podendo ser instaladas/executadas em nenhuma 
outra plataforma. 
O Android é uma grande promessa que já está se tornando realidade. No 
momento em que este texto estava sendo escrito, a versão do pacote de 
desenvolvimento atual era a 1.6. Em cada nova versão, os problemas vão sendo 
corrigidos, os recursos incrementados, o desempenho e a compatibilidade 
melhorados. 
O Android executa as aplicações desenvolvidas para ele através da máquina 
virtual personalizada chamada Dalvik VM. 
Podemos dar uma aprofundada sobre Android em seu site oficial: 
http://developer.android.com/index.html. 
Então, mãos a obra! 
 
 
 
 
 
 
 
Mini Curso de Android Página 4 
 
Tópico 2 
O que é Android Development Tools (ADT) 
 
O "Android Development Tools (Ferramentas de 
Desenvolvimento para Android)" é um plugin 
(extensão) para o Eclipse IDE que o deixa preparado 
para desenvolver aplicações para o Android de forma 
integrada e simplificada. Ele permite a criação e 
depuração de aplicações Android de maneira fácil e 
rápida. Algumas características básicas do plugin: 
 
a) Provê uma maneira simples de interação 
com o emulador, permitindo a inserção de "break-points", visualização das 
threads e processos atuais, entre outros... Diretamente dentro do Eclipse. 
 
b) Um assistente para criação de novos projetos, que ajuda a criar 
rapidamente um novo projeto Android (criando e configurando de forma 
básica todos os arquivos necessários) e lhe deixando pronto para começar. 
 
c) Automatiza e simplifica o processo de compilação e deploy da aplicação 
Android. 
 
d) Provê um editor de código fonte que lhe ajuda a escrever arquivos XMLs 
válidos para os arquivos de configuração e recursos do Android. 
 
e) Permite a geração do pacote "APK", que poderá ser distribuído para os 
usuários. 
 
Instalando Eclipse Galileo com ADT Plugin 
 O Eclipse é um IDE (Integrated Development Environment) para 
desenvolvimento de aplicações em Java. Ele permite que extensões (plugins) sejam 
adicionadas a ele, tornando-o mais completo e específico para certas tarefas. Vamos 
adicionar uma extensão para o Eclipse poder desenvolver aplicações e ter uma série 
de grandes facilidades (citadas anteriormente) para Android. 
 
Mini Curso de Android Página 5 
 
Nota: Para este mini-curso, estamos disponibilizando 
o Eclipse Galileu (3.5) já com Android ADT Plugin 
configurado. Porém, caso queira fazê-lo você mesmo, 
veja este link com as instruções: 
http://developer.android.com/sdk/eclipse-
adt.html#installing 
 
Para instalar o Eclipse Galileu, siga os seguintes passos (considere que os arquivos 
aqui citados estão dentro do diretório “softwares” deste curso): 
1) Para executar o Eclipse IDE, será necessário ter o pacote de 
desenvolvimento Java (Java JDK 6): 
a. Execute o arquivo “jdk-6u6-windows-i586-p.exe” e prossiga até o 
final. Este processo irá instalar o Java 6 Development Kit (pacote 
necessário para desenvolver e compilar aplicações em Java). 
b. Configure as variáveis de ambiente do seu sistema: 
i. “JAVA_HOME” para a pasta “C:\Arquivos de 
Programas\Java\jdk1.6.0_11\" 
ii. “PATH” para o conteúdo de “path” mais “C:\Arquivos de 
Programas\Java\jdk1.6.0_11\bin” 
c. Teste o seu ambiente: 
i. Abra o prompt de comando (cmd) e digite “java”, se não der a 
mensagem “java não é reconhecido...” é por que seu ambiente 
está pronto para executar o Eclipse; caso dê algum problema, 
repita os passos acima. 
 
2) Parainstalar o Eclipse Galileo (3.5): 
a. Descompacte todo o conteúdo do arquivo 
“eclipseGalileuAndroid.zip” para a unidade “C:\”. 
b. Um diretório chamado “eclipse” foi criado na unidade “C:\”. 
c. Entre no diretório “eclipse” na unidade “C:\” e execute o arquivo 
“eclipse.exe”. 
d. Se o Java JDK 6 estiver corretamente instalado no seu computador, o 
Eclipse IDE será executado. Caso haja algum problema relacionado a 
isto, reveja o passo 1. 
 
 
 
 
Mini Curso de Android Página 6 
 
Tópico 3 
O que é o Android SDK (Software Development 
Kit) 
Android SDK é um conjunto de bibliotecas 
padrão (APIs) e ferramentas para que os 
desenvolvedores possam se interagir e 
desenvolver para o sistema Android de maneira 
fácil e padronizada. Ela contém além das classes 
básicas e ferramentas para compilar, depurar e 
acompanhar aplicações em Android, um 
emulador para que as aplicações possam ser 
testadas, no próprio computador de 
desenvolvimento, antes de ser realmente instalado em um dispositivo real. Sem este 
kit, é impossível desenvolver aplicações para o Android; ele é o que faz tudo 
funcionar. 
 
Instalando o Android SDK e configurando as variáveis de ambiente 
Para instalar o Android SDK, siga os seguintes passos (considere que os arquivos aqui 
citados estão dentro do diretório “softwares” deste curso): 
1) Descompacte o conteúdo do arquivo “android-sdk-windows-1.5_r3.zip” 
para a unidade “C:\” 
2) Deverá ter sido criado o diretório “android-sdk-windows-1.5_r3” na 
unidade “C:\” 
3) Configure as variáveis de ambiente do seu sistema: 
a. “PATH” para o conteúdo de “path” mais “C:\android-sdk-windows-
1.5_r3\tools” 
b. Teste o seu ambiente: 
i. Abra o prompt de comando (cmd) e digite “android”, se não der 
a mensagem “android não é reconhecido...” é por que seu 
ambiente está pronto para executar o Eclipse; caso dê algum 
problema, repita os passos acima. 
4) Parabéns! Se os passos acima foram corretamente executados, você está 
pronto para começar a criar suas aplicações para o Android 1.5. 
 
 
 
Mini Curso de Android Página 7 
 
Tópico 4 
Android Virtual Devices (AVD) 
Android Virtual Devices (Dispositivos 
Virtuais do Android) é um conceito criado a 
partir do Android 1.5; ele serve para armazenar 
um conjunto de características, para que o 
emulador possa simular exatamente a 
configuração de um dispositivo real. 
É possível criar várias configurações para 
testar a aplicação em várias circunstâncias 
diferentes, por exemplo: 
Dispositivos com: 
a) Quantidade X de memória 
b) Banda de internet limitada a X kbps/s. 
c) Suporte a imagens 3D 
d) Cartão de memória limitado a X Gb 
e) Teclado virtual 
f) Gravador de Video e Áudio 
g) SMS 
h) Internet G3 
i) Google Maps 
j) Entre muitos outros... 
Todas as configurações podem ser combinadas, para que o teste seja preciso; 
pense em AVD como rodar sua aplicação em vários dispositivos diferentes: uns mais 
“possantes” e outros mais “fraquinhos”. Isto evita que o desenvolvedor tenha 
surpresas depois. 
 
Atenção: 
Para executar o emulador, é obrigatório informar um AVD existente. 
 
Criando um novo AVD (Android Virtual Device) 
 Abra o “prompt de comando (cmd)” e digite: 
a) android list targets 
Mini Curso de Android Página 8 
 
 
 
 
 
 
 
 
 
 
Imagem 01 – “ Comando ‘android list targets’ ” 
 
Estas são as plataformas disponíveis para o emulador do Android, as 
versões anteriores possuem recursos mais limitados. 
 
b) Para criar um AVD, é necessário escolher uma plataforma disponível 
(listadas no passo acima). Como vamos fazer um exemplo utilizando 
Google Maps API futuramente, vamos escolher a opção (ID) 3: 
Google APIs 
 
a. Digite no prompt de comando: 
 
i. android create avd –n CURSO_AVD –t 3 
 
b. Se a mensagem “Created AVD ‘CURSO_AVD’ based on Google 
APIs (Google Inc.)” surgiu no console, parabéns. Você criou 
um AVD chamado “CURSO_AVD” baseado na plataforma 1.5 + 
Google Maps com sucesso e já poderá executar o emulador do 
Android com esta configuração. 
 
c. Se quiser visualizar todos os AVDs criados em seu computador, 
basta digitar o comando “android list avd” e os AVDs serão 
listados. 
 
 
Mini Curso de Android Página 9 
 
Executando o emulador do Android com acesso à internet (configurações de 
Proxy) 
 Agora que já temos tudo configurado 
(Java JDK 6, Eclipse Galileo com ADT Plugin 
e o Android SDK com um AVD chamado 
“CURSO_AVD”), vamos executar o 
emulador do Android, para que possamos 
começar a realmente desenvolver nossa 
primeira aplicação. 
O emulador do Android é completo e 
carrega todo o sistema, ou seja, carrega o 
sistema operacional Linux, as bibliotecas, os 
drivers e a máquina virtual Dalvik VM. O 
emulador terá a capacidade e as restrições 
do AVD escolhido. Uma versão mais recente poderá executar uma versão anterior de 
AVD. 
 
Digite no prompt de comando: 
 
a) emulator –avd CURSO_AVD 
 
O emulador será executado. 
Dica: A execução do emulador é bastante demorada pela primeira 
vez. Então, lembre-se: Não é necessário fechar o emulador depois. 
Deixe-o aberto. 
 Atenção: Caso você utilize algum Proxy para acessar a internet, será necessário 
informar ao emulador o caminho para ele, senão, a internet não funcionará no 
emulador. 
Para informar o caminho do Proxy, digite o seguinte comando para executar 
o emulador: 
a) emulator –avd CURSO_AVD –http-proxy 127.0.0.1:3128 
a. Onde “127.0.0.1” deve ser substituído pelo IP do seu Proxy e 
“3128” pela porta do seu Proxy. 
 
 
Mini Curso de Android Página 10 
 
Tópico 5 
Configurando o Eclipse IDE para reconhecer o 
Android SDK 
 
Falta apenas um passo para podermos desenvolver nossa primeira aplicação em 
Android: informar ao plugin ADT dentro do Eclipse onde está o Android SDK. 
1) Abra o Eclipse IDE (C:\eclipse\eclipse.exe) 
2) Selecione o menu “Window” e “Preferences” 
3) Selecione no menu esquerdo da tela a opção “Android” 
4) Na tela “Android Preferences”, clique no botão “Browse” para localizar o 
diretório do Android SDK. 
5) Informe o diretório “C:\android-sdk-windows-1.5_r3” 
6) Clique em “Apply” 
7) Surgirá uma lista com os “Targets” disponíveis 
8) Selecione a terceira opção: “Google APIs” e clique em “Ok” 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Imagem 02 – “Configuração do Local do Android SDK” 
Mini Curso de Android Página 11 
 
Tópico 6 
Criando a primeira aplicação Android (Olá 
Mundo) 
 
Chegou o momento de criarmos a nossa primeira aplicação “Olá Mundo” em 
Android. Já estamos com tudo configurado e pronto, então, mãos à obra! 
No Eclipse, faça o seguinte: 
1) Clique no menu “File” -> “New” e escolha a opção “Other...” 
2) No diálogo “Wizards”, digite “Android” na caixa de pesquisa 
3) Nas opções que surgiram, selecione “Android Project” e clique em 
“Next” 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Imagem 03 – “Novo Projeto Android” 
Mini Curso de Android Página 12 
 
A janela “New Android Project” que surgiu serve para que você digite os dados do projeto que 
será criado. Preencha-a da seguinte forma: 
 Project Name: ProjetoOlaMundo 
 Build Target: Google APIs 
 Application name: OlaMundoAndroid 
 Package name: com.minicursoandroid.olamundoandroid 
 Create Activity: Principal 
 Min SDK Version: 3 
 
Clique em “Finish” 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Imagem 04 – “Preencher os dados do novo Projeto Android” 
 
 
 
Mini Curso de Android Página 13 
 
Tópico 7 
Estrutura básica de uma aplicaçãoAndroid 
Neste momento já temos a nossa aplicação “Olá Mundo” criada no Eclipse. 
Precisamos verificar a estrutura das aplicações Android para que saibamos 
exatamente aonde colocar cada recurso e o motivo das coisas estarem no lugar em 
que estão. 
 
O que é uma classe “Activity” 
 Uma Atividade é uma ação singular que o usuário pode realizar. Quase todas 
as atividades interagem com o usuário, então ela se responsabiliza por criar a janela 
na qual você coloca a interface com o usuário (através do método 
setContentView(View) ). Geralmente uma Atividade é apresentada ao usuário em 
fullscreen, mas nada impede que ela seja utilizada de outra maneira, como em telas 
flutuantes. Ao criar uma Atividade, sempre precisamos implementar dois métodos: 
 
onCreate(Bundle) – É aonde você inicia sua Atividade e define a UI (com 
setContentView(View) e o layout resource ). Assim como você pode obter os widgets 
(elementos de tela) que você precisará manejar, através do método 
findViewById(int). 
 
onPause() – É quando o usuário sai da sua aplicação. É neste momento que todas as 
informações necessárias devem ser persistidas. 
 
É importante notar que todas as Atividades devem estar definidas em 
AndroidManifest.xml para que seja possível inicializá-las através do método 
Context.startActivity(). 
 
Diretório de Recursos 
Estes são os diretórios de recrusos dentro de 
uma aplicação Android. Todos os recrusos da 
aplicação, tais como, textos, imagens, sons, vídeos 
etc. Devem obrigatóriamente estar dentro deste 
diretório “res” e em seus respectivos sub-diretórios. 
 Segue uma explicação detalhada de cada 
diretório: 
 
 
1) res/drawable/: 
Coloque neste diretório todas as imagens de sua aplicação (imagens de 
tela, de botões, ícones etc.). 
Mini Curso de Android Página 14 
 
2) res/layout/: 
Coloque neste diretório todos os arquivos XML que representam o layout 
de uma tela. 
3) res/values/: 
Coloque neste diretório todos os recursos relacionados a textos. Um 
arquivo com todos os textos da sua aplicação, por exemplo. 
 
A classe “R.java” 
 Esta classe é o “coração” do sistema Android. Ela representa, em forma de 
atributos Java, todos os recursos da sua aplicação que estão dentro dos diretórios 
explicados acima. Ela é gerada e atualizada automaticamente e não deve ser editada 
manualmente; o Eclipse fará isto automaticamente para você. 
 Por exemplo, temos dentro do diretório “res/drawable” a imagem 
“icon.png”; podemos acessá-la de dentro da nossa aplicação Android com a seguinte 
expressão: ‘R.drawable.icon’, onde “R” é a classe, “drawable” é o diretório e 
“icon” é o nome do recurso. Isto serve para quaisquer recursos presentes dentro dos 
diretórios de recursos. 
 
Navegador de Arquivos 
 O Android é um sistema operacional open-source baseado em Linux, então, é 
possível navegar pelo seu “HD”, navegando entre os diretórios, inserindo e excluindo 
aplicações, colocando arquivos de banco de dados etc. 
 Para navegar no sistema de arquivos do emulador (certifique-se de que o 
emulador esteja em execução), faça o seguinte no Eclipse: 
 
1) Clique no menu “Window” -> “Open Perspective” -> “Other...” 
2) Selecione o item “DDMS” e clique em “Ok” 
 
O Eclipse mudará sua perspectiva; com a perspectiva “DDMS” é possível 
monitorar o seu emulador do Android, verificando informações como “Threads”, 
“Heap” (espécie de memória da máquina virtual Java), “LogCat” (central de logs do 
Android), File Explorer (um explorador de arquivos que permite navegar e alterar os 
arquivos do sistema de arquivos do emulador), entre outras informações... 
 
Os dados das aplicações instaladas no Android ficam em seu próprio diretório 
dentro de “\data\data\%nomeDoPacote%*\ 
Os arquivos de banco de dados SQLite (vide tópico 9) ficam dentro do diretório 
da aplicação “\data\data\%nomeDoPacote%*\databases\” 
 * substitua “%nomeDoPacote% pelo nome do pacote da sua aplicação. 
 
Mini Curso de Android Página 15 
 
 Imagem 05 – “Eclipse IDE com a perspectiva DDMS” 
 
 
Tipos de arquivos do Android 
 O Android possui os seguintes formatos de arquivos: 
 
• .dex 
o São os bytecodes das classes Java compiladas. 
• .apk 
o É a aplicação Android completa, empacotada, pronta para 
ser instalada em um dispositivo móvel. Semelhante a um 
arquivo JAR; contém todos os recursos, todos os 
arquivos .dex e todos os arquivos de configuração e 
identificação necessários para instalação e execução da 
aplicação Android em um dispositivo móvel compatível. 
 
O arquivo “AndroidManifest.xml” 
 Todas as aplicações Android devem ter um arquivo AndroidManifest.xml 
(exatamente com este nome) no seu diretório raiz. Ele armazena as informações 
essenciais sobre a aplicação que está sendo desenvolvida. Algumas informações que 
ele armazena são, por exemplo, o nome do pacote da aplicação, componentes, 
atividades, serviços etc. Ele define também as informações de permissão da aplicação 
Android, por exemplo, acesso a internet, acesso a disco etc. Para mais informações, 
consulte este link: http://developer.android.com/guide/topics/manifest/manifest-intro.html 
Mini Curso de Android Página 16 
 
Fazendo deploy da aplicação “Olá Mundo” para o emulador 
 Agora que já conhecemos a estrutura de uma aplicação Android, vamos voltar a 
nossa aplicação “Olá Mundo”. Primeiramente, vamos alterar a perspectiva do Eclipse 
para “Java EE”; para isto, clique em “Window” -> “Open Perspective” -> 
“Other...”, selecione a opção “Java EE (default)” e clique em “Ok”. 
 Para compilarmos a nossa aplicação e fazermos o deploy dela para o emulador, 
faça os seguintes passos: 
1) Certifique-se de que o emulador está em execução (vide tópico 4). 
2) Clique com o botão esquerdo sobre “ProjetoOlaMundo” do lado esquerdo 
da tela. 
3) Selecione a opção “Run As” e “Android Application” 
A aplicação será compilada, empacotada e instalada no emulador do Android. 
Acompanhe o progresso da operação através do Console do Eclipse. 
 Quando estiver terminado, a aplicação surgirá na tela do emulador. 
Imagem 06 – “Fazendo deploy da aplicação “Olá Mundo” para o emulador” 
 
 
Mini Curso de Android Página 17 
 
Tópico 8 
Utilizando os componentes visuais do Android 
 
 Atenção: O Android possui muitos componentes 
visuais com muitas propriedades e podem ser utilizados de 
várias maneiras. Este mini-curso não tem o objetivo de 
demonstrar isto, porém, caso queira aprofundar-se no 
assunto, veja o site oficial: 
http://developer.android.com/guide/index.html ... Lá você 
encontrará todas as referências e exemplos necessários. 
Mãos à obra! 
 
Para acessar o layout visual da nossa aplicação “Olá Mundo”, clique duas vezes 
sobre o arquivo “layout.xml” dentro de “res/layout” (cada Activity terá o seu 
próprio layout); surgirá então o nosso layout dentro do Eclipse e uma aba do lado 
esquerdo com os componentes visuais disponíveis que podem ser inseridos no nosso 
layout. 
Criando um novo botão: 
 Para criar um novo botão, arraste um “Button” (que está dentro da aba 
“Views”) para debaixo do texto “Hello World, Principal!”; depois que o botão foi criado, 
clique em “main.xml” ao lado de “Layout” na parte inferior da tela de modelagem. Um 
editor de XML irá surgir com a representação do seu layout. 
 Nota: Todos os componentes possuem uma 
propriedade chamada “android:id”; ela é 
extremamente importante por que define a 
identificação do componente dentro do sistema e é a 
partir dela que será possível interagir com estes 
componentes em tempo de execução do sistema 
(atribuir o texto ou pegar o valor do texto digitado, 
por exemplo). O método utilizado para obter a 
referencia para um componente em tempo de 
execução é o “findViewById(id) da classe Activity”. 
 Na representação XML do layout, localize dentro do nó “<Button>”a 
propriedade “@+id/Button1” e mude para “@+id/primeiroBotao”. Neste momento, já 
temos como atribuir função ao nosso botão, pelo id “primeiroBotao”. 
Mini Curso de Android Página 18 
 
Agora dê um duplo clique em “Principal.java” dentro do pacote “src”, e copie o 
seguinte código (em negrito): 
 
public class Principal extends Activity { 
 /** Called when the activity is first created. */ 
 @Override 
 public void onCreate(Bundle savedInstanceState) { 
 super.onCreate(savedInstanceState); 
 setContentView(R.layout.main); 
 
 Button botao1 = (Button) findViewById(R.id.primeiroBotao); 
 botao1.setOnClickListener(new View.OnClickListener() { 
 
 public void onClick(View arg0) { 
 Toast toast = Toast.makeText(getApplicationContext(), 
 "Clicou no botão 1 !!!", 
 Toast.LENGTH_LONG); 
 toast.show(); 
 } 
 
 }); 
 
 } 
} 
 
Este código adiciona uma ação no botão quando ele for clicado; surgirá uma 
mensagem de alerta (Toast) com a mensagem "Clicou no botão 1 !!!". 
 
Na prática: 
Agora vamos fazer uma mini aplicação para treinar a utilização dos 
conceitos básicos dos componentes visuais do Android. Vamos agora utilizar 
os componentes de texto (EditText) juntamente com botões. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Mini Curso de Android Página 19 
 
Tópico 9 
Banco de Dados SQLite com Android 
 O Android tem suporte nativo a 
um banco de dados relacional: O SQLite 
(http://www.sqlite.org). Isto facilita 
muito o trabalho de armazenamento e 
leitura de dados no dispositivo. Ao 
contrário de JME, o Android permite que 
dados sejam armazenados e recuperados da base de dados através de comandos 
SQL; além de que a base de dados existe fisicamente, podendo ser copiada do 
dispositivo para uma unidade de backup, por exemplo; ou ainda, o banco de dados 
pode ser instalado no dispositivo já com os dados pré-carregados etc. Este realmente 
é um ótimo e muito útil recurso do Android. 
 
 Vamos ver (de forma simples e direta) como criar, acessar, gravar e recuperar 
dados do banco de dados SQLite na nossa aplicação. O código a seguir faz tudo o que 
é necessário (copie o código abaixo para um método e execute-o): 
 
 /* 
 * Atributo para armazenar a referência para SQLiteDatabase 
 */ 
 SQLiteDatabase myDB = null; 
 
 /* 
 * Lista para armazenar os resultados obtidos do banco de dados 
 */ 
 List<String> listaRegistros = new ArrayList<String>(); 
 
 /* 
 * Atributos para armazenar os nomes do banco de dados e da tabela 
 */ 
 String DATABASE_NAME = "BancoOlaMundo"; 
 String TABLE_NAME = "TabelaOlaMundo"; 
 
 try { 
 
/* obtém a referência para um banco de dados já existente ou cria uma nova 
referência, caso ele não exista. */ 
 myDB = 
getApplicationContext().openOrCreateDatabase(DATABASE_NAME, 
 MODE_PRIVATE, 
 null); 
 
 /* Cria a tabela no Banco de Dados. */ 
 myDB.execSQL("CREATE TABLE IF NOT EXISTS " + 
 TABLE_NAME + 
 " (nome VARCHAR, sobrenome VARCHAR, pais VARCHAR, idade INT(3));"); 
 
 // gravar 10 registros na tabela 
 for ( int x=1; x<=10; x++ ) { 
 
Mini Curso de Android Página 20 
 
/* variáveis para salvar no banco de dados... poderiam ser obtidos de um 
EditText, por exemplo... */ 
 String nome = "Nome " + x; 
 String sobreNome = "Sobrenome " + x; 
 String pais = "Pais " + x; 
 Integer idade = 2*x; 
 
 /* Instrução SQL para inserir o registro atual na tabela */ 
 myDB.execSQL("INSERT INTO " + 
 TABLE_NAME + 
 " (nome, sobrenome, pais, idade)" + 
 " VALUES " + 
 "('" + nome + "', " + 
 "'" + sobreNome + "', " + 
 "'"+ pais + "', " + 
 idade + ");"); 
 
 } 
 
 /* Query para obter os registros de todos os campos da tabela . */ 
 Cursor c = myDB.query(TABLE_NAME, 
 new String[] {"nome", "sobrenome", "pais", "idade"}, 
 null, 
 null, 
 null, 
 null, 
 null); 
 
 /* se existirem registros... então processa-os */ 
 if (c != null) { 
 
 /* Enquanto existirem registros obtidos e não percorridos... */ 
 while ( ! c.isAfterLast() ) { 
 
/* se for a primeira vez que está acessando o cursor, move-o para o primeiro 
registro... */ 
 if ( c.getPosition() == -1 ) { 
 c.moveToFirst(); 
 } 
 
 /* estes métodos retornam a posição da coluna dentro da query... 
 servem para obter o valor da coluna... */ 
 int posColunaNome = c.getColumnIndex("nome"); 
 int posColunaSobreNome = c.getColumnIndex("sobrenome"); 
 int posColunaPais = c.getColumnIndex("pais"); 
 int posColunaIdade = c.getColumnIndex("idade"); 
 
 /* 
 obter os valores das colunas do cursor... 
 como em JDBC, os métodos getString - retornam uma String 
 getInt - retornam um Int ... etc etc etc... 
 */ 
 String nome = c.getString(posColunaNome); 
 String sobrenome = c.getString(posColunaSobreNome); 
 String pais = c.getString(posColunaPais); 
 int idade = c.getInt(posColunaIdade); 
 
 // concatenar os dados dos campos em um único registro formatado 
 String registroObtido = "Nome: " + nome + 
 "Sobrenome: " + sobrenome + 
 "País: " + pais + 
 "Idade: " + idade; 
 
 
Mini Curso de Android Página 21 
 
 /* 
 Adicionar o registro obtido (formatado) dentro da lista de retorno... 
 */ 
 listaRegistros.add(registroObtido); 
 
 // mover o cursor para o próximo registro... 
 c.moveToNext(); 
 
 } 
 } 
 
 } finally { 
 
 // sempre fechar a conexão, caso ela exista 
 if (myDB != null) 
 myDB.close(); 
 
 } 
 
 
Você poderá também, ao invés de criar o banco de dados via código (como no código 
acima), utilizar um banco de dados já existente; basta que o banco de dados exista 
no diretório correto (vide tópico 7). 
 
 
Dica: Por questões de clareza e simplicidade, este 
código não seguiu critérios de orientação a objetos, porém, é 
extremamente recomendável que seja criado um DTO (Data 
Transfer Object) para representar a entidade da tabela de 
dados, e a lista resultante não deve ser do tipo <String> e 
sim do tipo de dados modelado e tipado. 
 
 
Informações aprofundadassobre acesso a dados SQLite no Android podem ser obtidas 
no site oficial: 
http://developer.android.com/reference/android/database/sqlite/SQLiteDatabase.html 
 
Então, mãos à obra! 
 
 
 
 
 
 
 
 
 
 
 
 
Mini Curso de Android Página 22 
 
Tópico 10 
Utilizando Google Maps com Android 
Um recurso muito interessante no Android é o suporte ao 
Google Maps. O Google Maps é um serviço acessado através da 
internet (não é instalado no dispositivo), contém mapas do 
mundo inteiro e é totalmente compatível com o Android. Para 
que o Google Maps funcione no Android, em ambiente de 
desenvolvimento, é necessário obter uma chave no site do 
Google; o processo é simples, fácil e rápido; porém, é necessário 
ter uma conta nos serviços Google (Gmail, Orkut etc.) e fazer 
login. Outro detalhe é que a chave vale apenas para um 
computador e é gerado com base na assinatura digital da 
máquina. 
A seguir, vamos fazer todos os passos para obtenção da 
chave e construção de uma aplicação bem simples utilizando o 
Google Maps. Depois disso, você estará apto (saberá os 
caminhos) para pesquisar e desenvolver suas próprias (e com mais recursos) 
aplicações Google Maps para o Android. As possibilidades são imensas. Então, mãos a 
obra! 
 
Obtendo a chave para acessar o serviço de mapas 
 Para poder usar o serviço Google Maps, é necessário ter uma chave de 
autorização devidamente gerada no site do Google; esta chave é gerada 
gratuitamente, basta ter uma conta nos serviços do Google (Gmail, Orkut etc) e fazer 
o registro. 
 
 Esta chave servirá para uso em apenas uma máquina por que ela é gerada com 
base na assinatura digital do emulador do Android, que será diferente em cada 
máquina onde for instalado (e consequentemente em cada dispositivo também). É 
uma maneira de o Google controlar os usuários que utilizam o seu serviço e 
posteriormente, quem sabe, cobrar por eles. 
 
Para obtermos uma chave, precisamos primeiro obter a assinatura digital da 
máquina onde está instalado o emulador do Android. Para isto, siga os passos abaixo: 
 
1) Digite no prompt de comando: 
 
keytool.exe -list -alias androiddebugkey -keystore "%User%*\.android\debug.keystore" -storepass 
android -keypass android 
 
* substitua “%User%” pelo diretório do usuário logado atual (C:\Users\Rodrigo, por exemplo) 
Mini Curso de Android Página 23 
 
 
Imagem 07 – “Gerando certificado MD5 para obter a chave do Google Maps” 
 
2) Copie o “Certificate fingerprint (MD5)” gerado para a sua máquina; no caso 
acima (8D:89:2E:54:E7:FA:DE:6C:9E:C5:D9:C9:4E:5B:B1:62). Este certificado 
é diferente para cada máquina, então, é obrigatório gerá-lo em cada máquina 
diferente que for utilizar os mapas. 
 
3) De posse do “Certificate fingerprint (MD5)”, entre no site 
http://code.google.com/intl/pt-BR/android/maps-api-signup.html; 
 
4) No site, leia os termos da licença e se concordar, marque a opção que 
está de acordo, cole o certificado obtido na caixa “My certificate’s...” e clique 
na opção “Generate API Key” 
 
 
 
 
 
 
 
 
 
 
 
 
 
Imagem 08 – “Solicitando a chave do Google Maps API” 
 
Mini Curso de Android Página 24 
 
5) Será solicitado que você faça login no Google, então, você deve ter uma conta 
ou senão você poderá criá-la neste momento. Faça o login. 
 
6) Sua chave será gerada e exibida pra você na tela, com um exemplo de como 
utilizar o componente “MapView” para exibir o mapa. 
 
Imagem 09 – “Chave do Google Maps API gerada” 
 
Pronto, você já está preparado para começar a desenvolver aplicações utilizando o 
Google Maps API no Android. 
 
Para informações mais detalhadas sobre este processo, por favor, verifique a 
documentação oficial: http://developer.android.com/guide/tutorials/views/hello-
mapview.html; 
 
Então, mãos a obra! 
 
 
Construindo uma aplicação simples 
 Acessar o serviço Google Maps no Android é extremamente simples, basta 
utilizar o componente “MapView”. Vamos fazer uma pequena aplicação para vermos 
como isso funciona na prática. 
 
1) Crie um novo Projeto Android baseado no Google Maps API (vide tópico 6) e 
use os seguintes nomes: 
 
 
 
Mini Curso de Android Página 25 
 
Project Name: ProjetoMapaSimples 
 Build Target: Google APIs 
 Application name: MapaSimplesAndroid 
 Package name: com.minicursoandroid.mapasimples 
 Create Activity: Principal 
 Min SDK Version: 3 
 
2) Clique em “Finish” 
3) Para que nossa aplicação funcione corretamente, precisamos importar a 
biblioteca (API) do Google Maps e informar ao Android que ela terá 
permissão para acessar a internet, para isto, abra o arquivo 
“AndroidManifest.xml: 
 
Insira: 
 <uses-library android:name="com.google.android.maps" /> 
 Dentro da tag <application> 
 
Insira: 
<uses-permission android:name="android.permission.INTERNET" /> 
 Depois da tag <application> 
 
 Dica: Para saber mais sobre as tags de permissão, acesse este link: 
http://developer.android.com/reference/android/Manifest.permission.html 
Imagem 10 – “Arquivo AndroidManifest.xml permitindo acesso à internet e importando 
a biblioteca da API do Google Maps” 
 
Mini Curso de Android Página 26 
 
4) Abra o arquivo “res/layout/main.xml” e substitua todo o seu conteúdo 
por este: 
 
 
<?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"> 
 
 <com.google.android.maps.MapView 
 android:id="@+id/mapView" 
 android:layout_width="fill_parent" 
 android:layout_height="fill_parent" 
 android:enabled="true" 
 android:clickable="true" 
 android:apiKey="0B0-L7d2MIQm2lx81czA67LoDbg-m0qDjH0iqXA" 
 /> 
 
</RelativeLayout> 
 
 Fazendo isto, estamos criando a tag “MapView”, responsável por exibir e 
renderizar o mapa dentro do Android. 
 
5) Mude o valor da tag: android:apiKey=”0B...” pelo valor que você obteve no 
site do Google e salve as alterações. 
6) Abra o arquivo “Principal.java” 
7) A classe “Principal.java” estende “Activity”, mude para “MapActivity” 
8) Substitua todo o valor do método “OnCreate(...)” por este: 
 
 super.onCreate(savedInstanceState); 
 setContentView(R.layout.main); 
 
 MapView mapa = (MapView) findViewById(R.id.mapView); 
 mapa.displayZoomControls(true); 
 
9) Crie o seguinte método: 
 
 @Override 
 protected boolean isRouteDisplayed() { 
 return false; 
 } 
 
10) Salve as alterações e faça deploy da aplicação para o emulador. 
11) Parabéns! Sua primeira aplicação de mapas está pronta! 
 
Se quiser se aprofundar mais no desenvolvimento de aplicação utilizando Google Maps 
no Android, não deixe de ver este link: 
http://code.google.com/intl/pt-BR/android/add-ons/google-pis/reference/com/google/android/maps/MapActivity.html 
 
Então, mãos à obra! 
 
Mini Curso de Android Página 27 
 
Tópico 11 
Referências e leituras recomendadas 
 
Referências Online: 
 
 Documentação oficial do Android: 
 
http://developer.android.com/sdk/android-1.5.html 
http://developer.android.com/guide/index.html 
http://developer.android.com/reference/packages.html 
http://developer.android.com/intl/en/community/index.html 
 
Portal em português sobre Android (local da comunidade Android): 
 
http://www.portalandroid.org/ 
 
Livros: 
 
Google Android: Aprenda a Criar Aplicações Para Dispositivos Móveis 
Ricardo R. Lecheta 
 
Android Essentials 
Chris Haseman