Material Android

Prévia do material em texto

e-Dea Jr. - Empresa Júnior da Computação UFC
Curso de Android
Apostila 
Professor André Fonteles
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
Índice
1. Introdução...............................................................................................................................3
2. Configurando o Ambiente de Desenvolvimento.....................................................................4
3.Criando, Entendendo e Executando sua Primeira Aplicação...................................................7
4. Visão Geral do Ambiente de Desenvolvimento......................................................................9
5. Activity...................................................................................................................................10
5.1 Trabalhando com Activities.....................................................................................11
5.2 Ciclo de vida de uma Activity..................................................................................13
6. Interface com Usuário...........................................................................................................14
6.1 Layouts básicos.......................................................................................................15
7. Android Manifest...................................................................................................................17
8. Resources...............................................................................................................................18
9. Mutimedia..............................................................................................................................19
10. Menu....................................................................................................................................22
11. Componente Webview.........................................................................................................24
12. Sensores................................................................................................................................26
13. Services.................................................................................................................................27
14. Widgets.................................................................................................................................29
15. Armazenamento Interno e Externo......................................................................................35
16. SQLite....................................................................................................................................37
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
1. Introdução
Android foi desenvolvido pela Open Handset Alliance e sua SDK para desenvolvimento de 
aplicativos foi liberada oficialmente em novembro de 2007. Mas o que ele é exatamente? 
Android é uma pilha de software que inclui um sistema operacional, um middleware e 
aplicações chaves. Ele foi projetado com amplo suporte ao desenvolvimento de aplicativos por 
parte de terceiros. Atualmente já conta com mais de 400.000 aplicativos em sua loja1, o 
Android Market.
 Figura 1
Entre as aplicações providas juntamente ao Android, encontram-se cliente de e-mail, 
programa para SMS, calendário, navegador, contatos e outras. Todas elas escritas em Java. 
Desenvolvedores que almejem criar aplicativos para essa plataforma possuem acesso a mesma 
API utilizada na criação dos aplicativos nativos do Android. Isso permite o desenvolvimento de 
aplicativos bastante flexíveis e que usam recursos avançados do sistema. A Figura 1 mostra um 
diagrama com os principais componentes do Android.
Mais informações sobre desenvolvimento em Android podem ser encontradas em 
http://developers.android.com . 
1 http://www.pcworld.com/article/247247/android_market_tops_400000_apps.html
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
2. Configurando o Ambiente de Desenvolvimento
Para o desenvolvimento de aplicações durante esse curso, nós usaremos as ferramentas: JDK, 
Eclipse, Android SDK e o plugin ADT para o Eclipse. Apesar de não ser obrigatória a utilização 
do Eclipse e seu plugin ADT (uma alternativa seria utilizar o NetBeans, por exemplo), eles são 
as ferramentas mais utilizadas pela comunidade. Esta seção descreve os passos necessários 
para a instalação do ambiente de desenvolvimento de aplicativos Android.
1. Download e instalação da JDK (Java Development Kit). 
• Disponível em http://www.oracle.com
2. Download e instalação do Eclipse. 
• Disponível em http://www.eclipse.org
3. Download e instalação do Android SDK (Android Standard Development Kit)
• Disponível em http://developers.android.com 
4. Download e instalação do plugin ADT (Android Development Tools) para o Eclipse
• Abra o Eclipse recentemente instalado.
• Acesse o menu Help > Install New Software e em seguida aperte o botão 
Add.
• Preencha os campos de acordo com a imagem abaixo e aperte o botão OK.
• Marque a opção Developer Tools e aperte o botão Next.
• Prossiga normalmente com a instalação e aceite os termos de compromisso.
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
• Reinicie o Eclipse.
• Seleciona Window > Preferences e depois Android. No campo SDK Location, 
você deve colocar o caminho onde instalação do Android SDK foi realizada.
5. Download da versão 2.3 do Android através do plugin.
• No menu superior do Eclipse, escolha Window > Android SDK Manager.
• Selecione para instalação os itens Tools e SDK Platform dentro de Android .
2.3.3 (API10), assim como mostra a figura a seguir.
• Aperte o botão Install [X] packages... e aguarde.
6. Criação de um Virtual Device
• No menu superior do Eclipse, escolha Window > AVD Manager.
• Apete o botão New...
• Preencha o formulário de acordo com a figura abaixo e pressiona o botão 
Create AVD. Obs: Não esqueça de alterar a memória RAM do device caso seu 
computador suporte.
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
7. Iniciando um Virtual Device
• Aperte o botão Start...
• Caso necessário, selecione a opção Scale display to real size e modifique o 
parâmetro Screen Size (in) para que o emulador caiba na sua tela.
• Aperte o botão Launch.
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
3. Criando, Entendendo e Executando Sua Primeira Aplicação
Tendo o seu ambiente de desenvolvimento configurado, a criação de um primeiro 
aplicativo Android é bastante simples. Nesta seção descreveremos como criá-loe executá-lo. 
Para a criação do seu primeiro aplicativo, os seguintes passos devem ser seguidos:
1. Acesse o menu File > New > Android Project.
2. Escolha um nome para o seu projeto em Project Name (no meu caso escolhido foi 
ProjetoTeste) e em seguida aperte o botão Next.
3. Escolha para qual versão do Android o projeto estará direcionado. No nosso caso, 
selecione o item Android 2.3.3.
4. Um novo formulário requerendo mais informações será apresentado. O campo 
Application Name determinará o nome da sua aplicação. Este será o nome da sua 
aplicação que o usuário verá (não confunda com nome do projeto). Escolha o nome do 
pacote Java da sua aplicação em Package Name. Os outros campos devem ser 
deixados como estão.
5. Aperte o botão Finish.
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
O projeto de sua primeira aplicação foi criado com sucesso. Agora já é possível visualizar o 
projeto no canto esquerdo da tela (pode variar de acordo com as configurações do Eclipse). Ao 
abrir o projeto dentro do Eclipse, é possível visualizar uma estrutura como a da figura abaixo:
Figura 2
Os principais diretórios e arquivos dessa estrutura são:
• src: Pasta que conterá o código-fonte Java escrito pelo desenvolvedor.
• gen: Esse diretório contem código-fonte gerado automaticamente pelo 
eclipse. Não se deve alterar manualmente esses códigos ou o projeto ocorrerá 
em erros.
• res: Diretório onde todos os recursos (imagens, arquivos em geral, etc...) do 
aplicativo são armazenados.
• AndroidManifest.xml: Arquivo onde metadados da sua aplicação serão 
informados. Aqui vão informações como, por exemplo, as permissões que o 
aplicativo necessita do sistema funcionar corretamente. 
Ao abrir o arquivo res > layout > main.xml você visualizará o layout (a tela) que sua aplicação 
criada exibirá ao usuário. Inicialmente essa tela deve conter o texto “Hello World, [nome]”, 
cujo nome poderá variar. Ao abrir o arquivo main.xml, também é possível visualizar no canto 
inferior da janela aberta uma aba chamada main.xml. Abra essa aba para editar o código xml 
que configura o layout. Será possível visualizar um código como o da Figura 3. A tag xml 
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
<TextView> é a responsável por apresentar a mensagem na tela do aplicativo. Altere o 
atributo android:text que contém o valor “@string/hello” para “Olá mundo Android!”. 
Figura 3
Agora vamos executar o aplicativo no emulador Android. 
1. Click com o botão direito do mouse na raiz da estrutura do projeto.
2. Selecione Run As > Android Application. Caso o emulador já esteja rodando, o 
aplicativo deverá ser instalado e executado automaticamente nele. Caso contrário, o 
Eclipse deverá se encarregar de inicializar o emulador por você e depois instalará e 
executará automaticamente o aplicativo. Obs: Esse passo pode demorar.
Ao termino dessa seção, você deve ter sido capaz de criar sua primeira aplicação, 
compreender a estrutura básica de um projeto Android e executar sua aplicação no emulador.
4. Visão Geral do Ambiente de Desenvolvimento
O plugin ADT é uma ferramenta de apoio muito poderosa que permite o controle minucioso de 
um dispositivo Android, quer seja ele emulado ou não. Entre suas funcionalidades, podemos 
citar: emulação de GPS, recebimento de chamadas e de SMS, acesso ao diretório de arquivos e 
captura de tela do dispositivo, etc. Para visualizar as principais funcionalidades do plugin, é 
necessário mudar de perspectiva no Eclipse. Acesse o menu Window > Open Perspective > 
Other..., em seguida selecione o item DDMS (Dalvik Debug Monitor Server). Ao selecionar a 
perspectiva DDMS, a tela do seu Ecilpse apresentará seções como Devices, Emulator Control, 
LogCat e outras. Nos parágrafos a seguir, descreveremos as principais seções e suas principais 
funcionalidades.
No canto da direita é possível ver duas seções: Devices e Emulador Control. A seção 
Devices apresenta todos os dispositivos, emulados ou reais, conectados ao seu ambiente de 
desenvolvimento. É possível ver todos os processos em execução (e forçá-los a parar, caso 
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
queira) e um botão com ícone de câmera que captura a tela do dispositivo selecionado. A 
seção Emulator Control é responsável por emular a localização do dispositivo, assim como 
ligações e recebimento de SMS.
Na parte inferior está a seção LogCat. Ele é como um console onde mensagens do 
sistema aparecerão. Por exemplo, nele é possível visualizar mensagens geradas pelo famoso 
“System.out.println()” do Java. O LogCat será seu melhor amigo no desenvolvimento de 
aplicações para Android.
Por fim, na parte principal da tela é possível encontrar a seção File Explorer que 
permite visualizar os arquivos e diretórios dos dispositivos.
5. Activity
Activity é um tipo de classe do framework Android que provê uma tela (interface) com a qual o 
usuário interage. Comumente essas classes podem utilizar arquivos XML de layout para definir 
suas telas. A maioria das aplicações conterá múltiplas activities fracamente acopladas, sendo 
uma a sua inicial (tela inicial do aplicativo). 
O fluxo comum em um programa se dá a partir de activities que iniciam novas 
acitivities. Quando uma activity é iniciada, a anterior para de executar e entra em uma pilha. O 
botão “back” presente nos dispositivo Android permite que o usuário seja capaz de voltar 
activities, semelhantemente ao que ocorre com um navegador web. 
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
5.1 Trabalhando com Activities
Para criar uma nova activity, é necessário implementar uma subclasse de Activity e 
sobrescrever alguns métodos. Os primeiros passos necessários para que você crie uma nova 
activity em um projeto Android será apresentado a seguir:
1. Dentro do seu projeto, clique com o botão direito no pacote onde suas classes se 
encontram e seleciona New > Class.
2. Escolha um nome para sua nova activity e sua superclasse como sendo Activity, assim como 
mostra a figura abaixo, e aperte o botão Finish. Uma janela de edição da sua nova classe se 
abrirá no Eclipse.
3. Clique com o botão direito do mouse no código-fonte de sua Activity e selecione Source > 
Override/Implement Methods... . Marque o item onCreate(Bundle) e aperte o botão Ok.
4. Agora, dentro do diretório res/layout do projeto, crie uma copia do arquivo main.xml e 
renomeie como mylayout.xml. Adicione alguma alteração ao layout para que ele seja 
diferente do conteúdo de main.xml
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
5. Dentro do método onCreate(), faça uma chamada ao método setContentView() passando 
R.layout.mylayout como parâmetro. Essa linha define que a nova activity utilizará o nosso 
layout que acabamos decriar.
Realizados os passos anteriores, o projeto conterá uma subclasse de Activity 
devidamente implementada, todavia algumas configurações de projeto ainda devem ser 
realizadas para que essa activity possa ser iniciada por outra. É muito comum que um novo 
programador Android esqueça essa configuração e não consiga entender porque erros 
estão ocorrendo ao tentar iniciar uma nova activity.
1. Abra o arquivo AndroidManifest.xml
2. Dentro de <application></application> adicione uma tag <activity android:name 
=”.NomeDaActivityCriada” /> , como mostra a figura abaixo. Esse passo permitirá que essa 
activity seja executada pela aplicação. Obs.: Caso uma activity não seja declarada no 
AndroidManifest.xml, ocorrerá erro em tempo de execução ao tentar abri-la.
3. Abra o arquivo main.xml e adicione um botão ao layout inserindo o seguinte trecho de 
código dentro de LinearLayout:
Esse código insere um botão que chamará um método onClick(View v) da activity em que ele 
for usado. Obs.: Esse método será criado posteriormente.
1. Abra a activity principal de seu projeto (a que foi criada automaticamente com ele).
2. Crie um método com a assinatura: onClick(View v). Esse método será chamado quando o 
botão que nós criamos for clicado.
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
3. Dentro do método criado, adicione o código:
Esse código é o responsável por abrir a nova activity. Você deve substituir a classe MyActivity 
pelo nome da classe criada por você.
Terminados os passos descritos, sua aplicação deverá ser capaz de, ao clicar no botão 
da tela principal, abrir a nova activity criada por você. A forma apresentada de abrir uma nova 
activity não realiza troca de informações entre activities. Por exemplo: se na primeira activity o 
usuário entrasse com seu nome em um formulário e esse valor fosse passado para a nova 
activity aberta após clicar no botão. 
Como faríamos para passar o valor da variável nome que teríamos na primeira activity 
para a segunda? Ao criar um intent, é possível utilizar o método putExtra(chave, valor) onde 
são inseridos uma chave e um valor correspondente. A activity que foi iniciada a partir desse 
intente, por sua vez, pode chamar o método (da própria superclasse Activity) getIntent(). Após 
recuperar o intent, um extra pode ser recuperado a partir do método 
getExtras().getString(“nome”), por exemplo. Apesar desse método de comunicação ser pouco 
prático, ele diminui consideravelmente o acoplamento entre activities.
5.2 Ciclo de vida de uma Activity
Durante a vida de uma activity, muitos eventos podem ocorrer. Ações do usuário como 
apertar os botões “home” e “back”, abrir novas telas (activities), ou o recebimento de 
chamadas como receber uma ligação, etc., geram vários eventos que podem ser capturados 
dentro de uma activity. Os seguinte eventos podem ser capturados pela classe Activity:
1. onCreate(): Chamado quando uma activity é criada. Aqui devem ocorrer a maioria das 
inicializações de seu objeto. 
2. onStart(): Chamado quando a activity está se tornando visível para o usuário. É seguido por 
onResume().
3. onResume(): Chamado quando a activity estiver prestes a começar a interação com o 
usuário. Nesse ponto a activity estará no topo da pilha. Animações apresentadas para o 
usuário normalmente devem ser iniciadas aqui.
4. onRestart(): Chamado após onStop() e logo antes de onStart() ser novamente chamado.
5. onPause(): Chamado quando o sistema está para trocar para uma outra activity . Esse 
método é usado tipicamente para parar qualquer ação que exija recursos do processador (ex.: 
processamentos em geral, animações) e para salvar informações de forma persistentes 
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
quando necessário. As ações aqui realizadas devem ser rápidas para que o sistema permaneça 
fluido. Pode ser seguido por onResume() ou onStop().
6. onStop(): Chamado quando uma activity não está mais visível ao usuário. Ocorre quando a 
activity está prestes a ser destruída ou quando outra activity a está cobrindo.
7. onDestroy(): ocorre antes da activity ser destruída. É a ultima chamada que uma activity 
recebe.
6. Interface com Usuário
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
Uma interface de usuário em uma aplicação Android é um conjunto de objetos do tipo 
View. Todo e qualquer componente de interface gráfica é uma subclasse de View. Por 
exemplo: EditText, TextView, Button, LinearLayout, ImageView.
Uma interface de usuário no Android pode ser criada de duas formas diferentes:
1. Criação de um arquivo xml com tags que correspondem a classes do tipo View
Método estático e consequentemente menos poderoso, mas a manutenção do código é 
facilitada devido a separação entre interface de usuário e código fonte em Java. Na prática, o 
framework Android se responsabilizará por ler o arquivo XML e gerar os respectivos objetos do 
tipo view automaticamente. Para obter acesso a um view criado, deve ser declarado um id 
dentro de sua tag no arquivo xml. Esse id será acessado através da classe R e utilizado no 
método findViewById(id) para recuperar o objeto correspondente.
2. Criação de elementos do tipo View em tempo de execução
Consiste na criação de objetos do tipo view através do próprio Java. Esse método é mais 
poderoso devido a sua característica dinâmica, todavia a manutenibilidade do código cai.
6.1 Layouts básicos
Em Interfaces de usuário (UI) existem views chamadas layout. Um layout define como 
views que estarão dentro dele serão dispostas. Para aqueles com experiência em Java, esse 
conceito é muito semelhante ao de layout em aplicações swing. Esses layouts são importantes 
pois facilitam a adaptação automática de conteúdos de UI em telas de diferentes tamanhos e 
densidades de pixels. 
Nesta seção, descrevemos um pouco de dois dos principais layouts e como eles 
funcionam. Além deles, como estudo futuro vale pesquisar sobre TableLayout e 
RelativeLayout.
1. FrameLayout
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
Figura 4
É o layout mais simples de todos. Qualquer view adicionada dentro dele será exibida na 
parte superior esquerda da tela. Se mais de uma view for adicionada, a ultima ficará por cima 
da anterior. É possível utilizar o atributo layout_gravity de uma view para especificar outro 
local de renderização. Na Figura 4 temos um exemplo de uso onde o botão será exibido no 
centro da tela.
2. LinearLayout
Alinha todas as views inseridas em uma única direção (horizontal ou vertical). A posição 
escolhida deve ser configurada no atributo orientation. As views inseridas serão enfileiradas 
uma após a outra como da esquerda para a direita, quando horizontal, ou de cima para baixo, 
quando vertical. Esse é o layout encontrado no arquivo layout.xml de forma padrão.
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br|falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
Figura 5
É possível configurar qual proporção da tela uma view ocupará dentro de um LinearLayout. 
Para tanto, é necessário alterar a propriedade layout_weight da view. O valor padrão para essa 
propriedade é 0, que significa que ela ocupará apenas o espaço padrão. Um número maior que 
zero fará com que a view ocupe o maior espaço possível na tela, a menos que existam outras 
views com números ainda maiores. Caso existam várias views com pesos diferentes, o espaço 
ocupado por elas será proporcional ao seu peso. A Figura 5 mostra um exemplo de uso do 
LinearLayout com pesos diferentes em suas views.
Exercício: Criar uma calculadora com dois componentes EditText, um ComboBox, um TextView 
e um Button. No ComboBox o usuário deverá escolher qual operação será realizada com os 
números que devem ser inseridos nos componentes EditText. Ao clicar no Button, o programa 
deve calcular e exibir o valor no TextView.
• Dica: Utilize o método findViewById(id) da classe Activity. Será necessário 
realizar o casting para o subtipo apropriado (ex.: de View para EditText).
7. AndroidManifest
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
Toda aplicação necessita de um arquivo AndroidManifest.xml. Esse arquivo contém 
informações sobre sua aplicação que o Android necessita para que seu código seja executado 
corretamente e em segurança. Entre as principais informações que estão ou podem estar 
presentes no AndroidManifest.xml, podemos citar:
• Nome do pacote Java da aplicação (serve como identificador único da sua 
aplicação);
• Descrição dos componentes que sua aplicação contem (ex.: activities e 
services);
• Permissões de usuário que seu aplicativo necessita para rodar em um 
dispositivo (ex.: acesso a internet e localização de usuário);
• Declaração de qual API Android mínima é necessária para rodar o aplicativo.
A Figura 6 apresenta um exemplo simples de AndroidManifest.xml.
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
Figura 6
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
Dentro das propriedades da tag manifest da figura são configurados o nome do 
pacote, a versão do código e a versão do aplicativo (esta última será a que aparecerá para o 
usuário final).
Na tag uses-sdk, a propriedade minSdkVersion determina qual a versão mínima do 
Android necessária para que o aplicativo seja instalado. Caso a versão seja superior ao do 
dispositivo, o Android não permitirá a instalação do aplicativo.
Em application a propriedade icon define o ícone do aplicativo e label, seu nome. Está 
declarada também uma activity chamada TestLayoutActivity que será a inicial do sistema que 
utiliza esse AndroidManifest.xml.
Por fim, a tag uses-permission possui o atributo name com o valor 
android.permission.INTERNET. Essa declaração significa que o aplicativo necessita de 
permissão para acesso a internet para seu funcionamento.
8. Resources
A pasta res (resources) de um projeto de aplicativo é onde recursos como imagens, 
layouts e strings são armazenados. Além desses tipos, existem também alguns mais 
avançados, como menus e animações. 
Para acessar esses recursos de dentro do código Java é utilizada a classe R, que é 
gerada automaticamente pelo ambiente. Nela estão presentes os ids de todos os recursos 
disponíveis. A API do Android disponibiliza uma séria de métodos que possibilita o acesso 
ao recurso através de métodos que recebem o id como parâmetro (ex.: 
setContentView(id) de Activity e setText(id) da classe TextView).
Figura 7
Outra forma de referenciar recursos é de dentro de outro recurso. Em layouts, por 
exemplo, as vezes é necessário fazer utilizar uma string ou uma imagem que esteja nos 
recursos. Isso se dá através da seguinte sintaxe: @string/nomedastring (para strings) e 
@drawable/nomedaimagem (para imagens). A referência sempre iniciará com um @ 
seguido do tipo de recurso (drawable, layout, string, etc) seguido por um caractere / e o 
nome do recurso. A Figura 7 apresenta um exemplo.
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
É possível definir recursos que devem ser usados apenas em determinadas configurações 
do dispositivo. Para fazer isso, é necessário adicionar um qualificador ao final do nome da 
pasta onde esses recursos devem estar. Por exemplo: além da pasta res/layout onde os 
layouts padrões do sistema se encontram, é possível criar o diretório res/layout-land que 
conterá arquivos de layout que serão usados automaticamente pelo sistema quando os 
sensores detectarem que o dispositivo se encontra deitado (posição landscape). Assim, 
poderia ser criado um main.xml default que ficaria em res/layout e um outro main.xml que 
ficaria em res/layout-land que seria utilizado automaticamente quando o celular estivesse 
deitado. Outra utilização dessa funcionalidade é para internacionalização. Para isso, deve ser 
adiciona a sigla da língua (ex.: strings-pt e strings-en).
Por padrão, quando um novo projeto no Eclipse é criado, também são criadas várias pastas 
drawable: drawable-hdpi, drawable-mdpi e drawable-ldpi. Essas pastas devem conter recursos 
direcionados para diferentes densidades de pixeis na tela.
9. Multimedia
O framework Android inclui suporte para uma variedade de tipos de mídia (media). É 
possível executar sons e vídeos a partir de arquivos presentes no diretório /res de um projeto, 
bem como arquivos presentes no sistema de arquivo (cartão SD ou memória interna). Além 
disso, o framework também permite a execução de streams de áudio e vídeo recebidas pela 
internet. Entre os tipos de arquivo que podem ser executados nativamente pelo Android 
estão: .3gp, .mp4, .m4a, .aac, .flac, .mid, .igg, .mkv, .wav.
Para a execução dessas mídias, o framework disponibiliza a classe MediaPlayer. A seguir, 
demostraremos como utilizar algumas das funcionalidades dessa classe.
• Execução de Áudio do diretório /res
1. Adicione um arquivo de áudio suportado (ex.: mp3) no diretório /res/raw 
de um projeto Android.
2. Renomeie o arquivo para “musica” (ex.: musica.mp3). Obs.: É importante 
observar que arquivos dentro do diretório /res devem possuir apenas os 
caracteres de a à z, números de 0 à 9, underline (“_”) e ponto (“.”). Caso 
contrário, o projeto apresentará erros.
3. Adicione o trecho de código apresentado a seguir em alguma classe do seu 
projeto. Obs.: Para fins de teste, coloque dentro do método onCreate() de 
sua Activity principal.
 
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
Terminado o passo a passo descrito anteriormente. Você deve se capaz de executar 
um áudio presente no diretório /res de seu projeto. 
Ao executar qualquer áudio ou vídeo utilizandoa classe MediaPlayer, é necessário 
chamar o método prepare() ou prepareAsync(), antes de start(). Esses métodos preparam o 
player para execução do conteúdo. O primeiro é executado de forma síncrona (o programa 
trava até o termino da chamada do método) e o segundo de forma assíncrona (o programa 
não para, ao invés disso recebe um alerta ao termino da execução). No exemplo anterior, isso 
não foi necessário, pois o método create() já chama prepare() internamente.
Em muitos casos, a chamada de prepareAsync() é mais conveniente do que prepare(), 
pois quando a mídia é muito grande, a preparação pode demorar e consequentemente travar 
o programa.
• Execução de Áudio por stream da internet
O código abaixo é o trecho necessário para executar uma stream de áudio a partir 
da internet.
No código acima, inicialmente é criada uma String com um endereço onde o áudio se encontra 
(http://libsyn.com/media/eslpod/ESLPod774.mp3). O endereço apresentado é de um áudio de 
aula de inglês. Na linha seguinte é criado um objeto do tipo MediaPlayer que será responsável 
por executar a stream.
O método setAudioStreamType() de MediaPlayer serve para configurar qual tipo de mídia será 
executado. No nosso caso será uma stream de música. No método setDataSource() é 
configurada a URL onde se encontra o áudio.
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
Como falado anteriormente, um MediaPlayer precisa ter os métodos prepare() ou 
prepareAsync() chamados antes da chamada ao método start(). No caso do nosso código, é 
utilizado o prepareAsync(), pois a preparação de uma stream de áudio remoto é 
potencialmente demorada e, portanto, pode travar o aplicativo. Para que prepareAsync() seja 
chamado, é necessário, antes de tudo, definir um objeto do tipo OnPrepareListener que terá o 
método onPrepared() chamado quando a preparação for concluída. Dentro desse método 
chamaremos start(). Após definido o listener, basta chamar prepareAsync() normalmente.
O código apresentado pode gerar uma exceção em Java, portanto é necessário definir os 
blocos Try e Catch para que a exceção seja devidamente tratada e o código seja compilado.
• Execução de vídeo do diretório /res
1. Altere o Layout de sua activity para que ele apresente um componente 
button, que servirá para iniciar o vídeo, e um componente VideoView, que 
exibirá o vídeo. Um código de exemplo é apresentado a seguir.
 
2. Adicione um arquivo de vídeo suportado dentro de /res/raw e renomeie 
para vídeo (ex.: vídeo.3gp).
3. Dentro de sua Activity, crie um método onClick() que será chamado ao 
clicar no botão.
4. Recupere a referência para o objeto VideoView utilizando o método 
findViewById().
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
5. Dentro de onClick() adicione o trecho de código a seguir
A primeira linha cria o MediaPlayer e realiza algumas configurações automaticamente, como 
por exemplo: chamar o método prepare(). Dentro de videoView, existe um objeto do tipo 
SurfaceHolder. Ele deve ser recuperado e adicionado ao MediaPlayer através do método 
setDisplay() para que o vídeo seja exibido nele. Por fim, start() deve ser invocado.
10. Menu
No Android, menus são uma forma de interação muito comum entre usuário e dispositivo. 
A grande maioria dos dispositivos Android possui um botão dedicado para a apresentação do 
menu de uma aplicação. A figura abaixo apresenta duas telas de uma aplicação com seu menu 
sendo exibido na segunda. 
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
Além dos menus convencionais, existem também menus como contextuais e popup. No 
passo a passo a seguir, nós apresentaremos como se dá a criação de um menu convencional.
1. Dentro de um projeto Android, crie o diretório res/menu .
2. Aperte com o botão direito no novo diretório criado e selecione New > Other...
3. Abra a pasta Android, selecione o item Android XML File e aperte no botão Next.
4. Uma nova janela se abrirá. Escolha o nome “my_first_menu” para o arquivo XML no 
campo File. Certifique-se que o item menu está selecionado dentro de Root Element.
5. Aperte o botão Finish.
6. Procure uma aba no canto inferior direito da tela de edição do menu que permitirá 
que o código XML seja editado.
7. Edite o código XML de acordo com o exemplo da imagem abaixo. Cada tag item 
representa um item do menu. Seus atributos id e title são respectivamente um 
identificador para acesso ao item pelo código e o texto que será apresentado ao 
usuário. Obs.: Também é possível utilizar o atributo icon para definir um ícone para o 
item.
 
8. Agora, para definir um menu para uma Activity, é necessário sobrescrever o método 
onCreateOptionsMenu() da Activity. Veja o código que deve estar dentro de Activity a 
seguir:
 
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
Feito o passo a passo anterior, sua aplicação já será capaz de exibir um menu quando o 
usuário apertar o botão menu do dispositivo. Da forma atual, quando um usuário seleciona 
um item do menu o aplicativo ainda não consegue detectar.
Para saber quando um item foi clicado pelo usuário, o método onOptionsItemSelected() 
deve ser sobrescrito. Sempre que um item do menu é escolhido por um usuário, esse método 
é chamado passando qual item foi escolhido como parâmetro. O trecho de código a seguir 
mostra como capturar eventos de itens selecionados no menu.
Quando o evento da seleção de um item for capturado, deve-se retornar true. Caso 
contrário deve-se chamar o método da classe pai e retornar seu resultado. 
11. Componente WebView
O Framework Android, assim como muitos outros, possibilita inserção de conteúdo web 
em aplicativos. A importância dessa característica se deve ao fato de que uma aplicação 
baseada em conteúdo web pode ser mais facilmente portada para outros dispositivos. Devido 
ao suporte praticamente universal de dispositivos a esse tipo de tecnologia, o conteúdo web, 
de maneira geral, não demanda adaptação de código para cada dispositivo.
Apesar dos benefícios da utilização dessa abordagem no desenvolvimento de aplicativos, 
códigos desenvolvidos para web possuem uma grande limitação: fraca integração com 
hardware do dispositivo. Recursos como câmera, sensores em geral, entre outros, não são 
facilmente acessados por aplicações web. Para resolver esse problema, o Android permite que 
código JavaScript seja integrado com código Java de aplicações comuns.
O passo a passo a seguir explica como utilizar o componente WebView dentro de uma 
aplicação Android.
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
1. Adicione o componente WebView em um layout de acordo com o exemplo abaixo. 
 
2. Adicione permissão de acesso a internet no seu AndroidManifest.xml dentro datag 
<manifest>.
 
3. Configure o objeto webView para abrir a página do Google, de acordo com o exemplo 
abaixo:
 
Após concluir o passo a passo anterior, seu aplicativo deverá abrir um componente 
WebView que apresente a página do Google.
O próximo passo a passo ensinará como alterar o aplicativo criado anteriormente para 
integrar código JavaScript com código Java Android.
1. Habilite a execução de JavaScript no seu webview com o comando abaixo. O comando 
deve ficar antes da chamada ao método loadUrl(). Obs.: Por padrão, o componente 
WebView não permite execução de JavaScript.
 
2. Crie uma classe que servirá como interface entre o JavaScript e o Java de acordo com 
o exemplo a seguir. Obs.: O nome utilizado para essa classe foi arbitrariamente 
escolhido, não há necessidade de usar o mesmo nome. O método showToast() da 
classe será o que o JavaScript invocará. 
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
3. Configure no seu webview a nova classe criada como interface entre o Android e o 
JavaScript. Utilize o exemplo abaixo como guia. Esse trecho também deve ser inserido 
antes de loadUrl(). Obs.: A string “androidInterface” define como o código JavaScript 
chamará o código Android.
4. Altere o parâmetro de loadUrl(). Agora, ao invés de carregar o site do Google, ele 
deverá carregar a url: http://216.224.183.133/testeandroid/4.html . Obs.: Essa url já 
contem o código JavaScript que se integrará com o código Java.
O passo a passo anterior ensina como realizar a integração entre Android e JavaScript, mas 
apenas do lado do Android. A url http://216.224.183.133/testeandroid/4.html nos dá um 
exemplo de como fazermos isso do lado do JavaScript. A abaixo apresenta o código fonte 
JavaScript que está integrado.
Exemplo de código JavaScript se integrando ao Android
Perceba que, dentro do método showToast() do JavaScript, é acessado o objeto 
chamado androidInterface. O nome da referência a esse objeto foi definido no passo a passo 
anterior quando chamamos o método addJavaScriptInterface() de webview passando a string 
“androidInterface”. Na verdade, o androidInterface no JavaScript representa o objeto 
webViewAppInterface do passo a passo. Assim, quando o código JavaScript chama 
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
androidInterface.showToast(“Coded by André Fonteles”), na verdade ele está chamando 
webViewAppInterface.showToast(“Coded by André Fonteles”) do código Java do passo a passo.
12. Sensores
A maioria dos dispositivos Android possui uma séria de sensores embarcados em seu 
hardware. Entre eles, podemos citar acelerômetro, termômetro, giroscópio, sensor de luz e 
campo magnético. Esses sensores são utilizados de formas diversas, como para controlar um 
jogo ou controlar o brilho da tela de acordo com a luz ambiente. 
O Android disponibiliza uma API simples para interação com sensores. As principais classes 
e interfaces utilizadas para tanto são: SensorManager, Sensor e SensorEventListener. Objetos 
do tipo Sensor representam sensores e são adquiridos através de objetos SensorManager. 
Objetos do tipo SensorEventListener quando registrados no SensorManager recebem, 
capturam eventos gerados por sensores. Esses eventos informam dados sensoreados como a 
temperatura ou luminosidade, por exemplo. A Figura 1 mostra um exemplo de código de um 
sistema que recupera a luminosidade ambiente através de um sensor de luz e exibe o grau de 
luminosidade em um TextView. Para utilizar sensores diferentes, seria necessário alterar o 
parâmetro Sensor.TYPE_LIGHT para outros como Sensor. TYPE_GRAVITY, por exemplo.
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
Figura 1 Exemplo de código de sensoriamento
No exemplo apresentado na Figura 1, a própria activity implementa a interface 
SensorEventListener. O método registerListener() de SensorManager registra um listener (no 
nosso caso a própria activity) para um determinado sensor. O último parâmetro do método se 
refere ao tempo entre a geração de um evento e outro. 
13. Services
Services são componentes que podem executar operações em segundo plano de longa 
duração. Diferentemente de acitivities, um service não provê uma interface para o usuário. 
Tarefas como downloads e execução de músicas, por exemplo, geralmente são efetuadas por 
um Service.
Trabalhar com um service é muito semelhante a trabalhar com uma activity. Ambos 
possuem um ciclo de vida com métodos como onDestroy(), onCreate() e etc. Além disso, para 
iniciar um Service também é utilizada a classe Intent. Apesar de servir para tarefas em segundo 
plano, um service é executado por padrão na thread principal. Assim, em alguns casos, é 
necessários trabalhar com threads workers (threads secundárias). 
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
A Figura 2 apresenta um código de um Service simples contendo apenas três métodos. O 
método onStartCommand() é chamado sempre que um Service é iniciado. Ele recebe como 
parâmetros um intent (que foi utilizado para iniciar o service) e dois parâmetros do tipo int. No 
caso dó código da Figura 2, o intent possui um Extra contendo um texto que será apresentado 
em um Toast quando o service for iniciado. Em onDestroy() é apresentado mais um Toast, 
dessa vez antes do service parar. O método onBind() é utilizados por services avançados que 
disponibilizam uma interface de interação com outros componentes. No nosso caso, não o 
utilizamos, portanto retornamos null.
Figura 2 Exemplo simples de service
A Figura 3 mostra um trecho de código que inicializa o service da Figura 2. Existe uma 
semelhança muito grande entre abrir uma nova activity e um novo service. A criação do intent 
se dá da mesma forma. Além disso, também é possível passar extras. A diferença está no 
método startService() que deve ser chamado ao invés de startActivity(). Também é possível 
chamar o método stopService() passando o intent como parâmetro para parar o serviço.
Figura 3 Exemplo de código para iniciar um service
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
14. Widgets
Widgets são miniaturas de aplicações que podem ser inseridas em partes de outras 
aplicações (normalmente a tela home do Android). Vários aplicativos como players de músicas, 
leitores de notícias e redes sociais oferecem widgets que permitem ver a música que está em 
execução ou as últimas novidades da rede. A Figura 4 apresenta o widget de busca do Google, 
destacado dentro do retângulo vermelho. Esse widget não é nada mais do que um atalho para 
um aplicativo de busca do Google.
Figura 4 Widget de busca do Google
Este tópico não procura tratar de forma extensiva o assunto de widget, mas prover 
conhecimento para que o leitor possa criarseu primeiro. Os principais passos para criar um 
widget simples são:
1. Criar um XML que definirá sua interface;
2. Criar outro XML para definir suas configurações, como tamanho na tela e perí -
odo entre atualizações de conteúdo interno;
3. Criar uma classe do tipo WidgetProvider para controlar o widget; 
4. Configurar a WidgetProvider no AndroidManifest.xml.
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
O XML da interface do widget deve ser simples, contendo apenas Views do tipo: 
Framelayout, Linearlayout, Relativelayout, AnalogClock, Button, Chronometer, ImageButton, 
ImageView, ProgressBar, TextView, ViewFlipper, ListView, GridView, StackView e 
AdapterViewFlipper. Classes que herdem de qualquer uma dessas não são suportadas.
O WidgetProvider é responsável por atualizar os dados de dentro de um widget. Por 
exemplo: um widget de notícias recebe as últimas notícias a partir do conteúdo fornecido pelo 
WidgetProvider.
A seguir, iniciaremos um passo a passo para a criação de um widget que simula o 
lançamento de um dado de seis lados:
1. Crie um projeto Android sem nenhum activity chamado MyWidget.
2. Crie um novo XML de layout chamado widget_layout.xml com apenas um 
TextView e um fundo preto. O conteúdo do XML pode ser visto a seguir.
3. Crie dentro do diretório res uma pasta chamada xml.
4. Crie um arquivo chamado widget_info.xml dentro da nova pasta criada. O 
conteúdo do XML deve ser de acordo com o código a seguir. Obs: Esse arquivo 
definirá qual o XML de layout do widget e seu tamanho.
5. Agora crie uma nova classe chamada MyWidgetProvider que estenda de 
AppWidgetProvider. O conteúdo deve ser como o apresentado a seguir.
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
6. Abra o AndroidManifest.xml e adicione o trecho de código abaixo dentro da 
tag <application>. Esse código registra o MyWidgetProvider para receber as 
mensagens para atualizar o widget.
7. Mande executar o programa. Aguarde até uma mensagem no Console do 
Eclipse afirmar que o aplicativo foi instalado.
8. Após instalado, vá para a tela inicial do Android, clique(toque) e segure a tela 
por alguns segundos. Uma lista será aberta. Selecione a opção Widgets.
9. Escolha o widget chamado MyWidget. 
Ao término do passo a passo, será apresentado um widget na tela inicial do 
dispositivo. Clique sobre o widget e um novo número será gerado pelo MyWidgetProvider para 
simular o lançamento do dado.
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
15. Armazenamento Interno e Externo
Aplicações desenvolvidas até o momento nessa apostila não capazes de realizar 
persistência de dados. Isto é, ao fechar abrir novamente as aplicações, elas perdiam todos os 
dados, pois não eram capazes de salvá-los em uma memória não volátil. Nesta seção será 
abordada uma das formas se realizar persistência de dados: o armazenamento em arquivo. 
A escrita e leitura de arquivos no Android são muito semelhantes às realizada no Java. 
Podem ser utilizadas classes como FileInputStream, para leitura, e FileOutPutStream, para 
escrita, por exemplo. O armazenamento no Android pode se dar em dois lugares: 
internamente, na memória interna do celular, ou externamente, em um cartão SD por 
exemplo.
O armazenamento interno tem entre suas principais características:
• Conteúdo pode ser particular de uma app;
• Usuário não são capazes de alterar os dados por fora da app;
• Os dados estão sempre disponíveis;
• Não requer permissão do usuário;
• Quando a app é desinstalado os dados são removidos; e
• A capacidade de armazenamento costuma ser menor que o externo.
A Figura 1 apresenta um código de exemplo onde é realizada a escrita em um arquivo na 
memoria interna do celular. 
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
Figura Exemplo de código de escrita e leitura em memória interna
O armazenamento externo, por sua vez, possui como principais características:
• Conteúdo púplico para outros aplicativos;
• Usuários podem acessar e alterar os dados;
• Os dados não estão sempre disponíveis (o cartão pode estar sendo utilizado pelo 
PC, por exemplo); e
• Capacidade de armazenamento geralmente é maior.
• Requer permissão no AndroidManifest.xml para escrita 
(android.permission.WRITE_EXTERNAL_STORAGE)
A Figura 2 apresenta um trecho de código de armazenamento externo. Existe uma grande 
semelhança entre os dois tipos com relação ao código.
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
Figura Exemplo de código de escrita e leitura de armazenamento externo
16. SQLite
O SQLite2 é um mecanismo de banco de dados relacional direcionado para dispositivos 
com recursos limitados. Seu funcionamento, a princípio, é semelhante a outros bancos de 
dados como MySQL e PostgreSQL, todavia muitos das funcionalidades que não são 
absolutamente necessárias foram removidas para economia de recursos. O SQLite está 
2 http://www.sqlite.org/
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
inserido dentro do Android, porem é uma ferramenta open source desenvolvida por uma 
comunidade internacional que não está diretamente ligada ao Google. 
Criar programas que utilizem SQLite requer um conhecimento mínimo da linguagem SQL. 
Caso seja necessário, mais informações podem ser encontradas em 
http://www.sqlite.org/docs.html. 
O passo a passo a seguir apresenta criará uma aplicação que utiliza banco de dados SQLite 
no Android. A aplicação consiste em uma activity que insere dados numa tabela chamada 
“pessoa” no banco de dados e depois recupera esses dados e apresenta em um TextView.
1. Crie um novo projeto Android. Escolhe o nome br.ufc.sqlite como nome do pacote
2. Aperte com o botão direito do mouse no projeto e escolha New < Package. O 
nome do novo pacote deve ser br.ufc.sqlite.model . 
3. Dentro do novo pacote criado, crie uma classe chamada Pessoa com nome e 
endereço. O código da classe deve ser como apresentado abaixo:
public class Pessoa {
private String nome;
private String endereco;
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public String getEndereco() {
return endereco;
}
public void setEndereco(String endereco) {
this.endereco = endereco;
}
}
4. Crie um novo pacote chamado br.ufc.sqlite.dao.
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC5. Dentro desse pacote, crie uma nova classe chamada MySQLiteOpenHelper de 
acordo com o código apresentado abaixo. Obs: Essa classe contem o código SQL 
para criação do banco de dados que será utilizado. 
public class MySQLiteOpenHelper extends SQLiteOpenHelper {
// Nome da base de dados
public static final String DATABASE_NAME = "thingstodo.db";
// Versão da base
public static final int DATABASE_VERSION = 1;
// Nome da tabela pessoa
public static String TABLE_PESSOA = "pessoa";
// Nomes dos campos da tabela pessoa
public static String COLUMN_NOME = "nome";
public static String COLUMN_ENDERECO = "telefone";
public static String[] allColumns = { COLUMN_NOME, COLUMN_ENDERECO };
// SQL de criação do banco de dados
private static final String DATABASE_CREATE = 
"CREATE TABLE "+ TABLE_PESSOA + "( " + 
COLUMN_NOME + " TEXT," +
COLUMN_ENDERECO + " TEXT" +
");";
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
public MySQLiteOpenHelper(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}
@Override
public void onCreate(SQLiteDatabase database) {
database.execSQL(DATABASE_CREATE);
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL("DROP TABLE IF EXISTS " + TABLE_PESSOA);
onCreate(db);
}
}
6. Ainda no pacote dao, crie uma nova classe chamada PessoaDAO. Essa classe será 
responsável por inserir dados e recuperá-los do banco de dados.
public class PessoaDAO {
// Database fields
private SQLiteDatabase database;
private MySQLiteOpenHelper dbHelper;
public PessoaDAO(Context context) {
dbHelper = new MySQLiteOpenHelper(context);
}
public void open() throws SQLException {
database = dbHelper.getWritableDatabase();
}
public void close() {
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
dbHelper.close();
}
public boolean insertPessoa(Pessoa pessoa) {
ContentValues values = new ContentValues();
values.put(MySQLiteOpenHelper.COLUMN_NOME, pessoa.getNome());
values.put(MySQLiteOpenHelper.COLUMN_ENDERECO, pessoa.getEndereco());
long insertId = database.insert(MySQLiteOpenHelper.TABLE_PESSOA, null, values);
if(insertId < 0)
return false;
else
return true;
}
public Pessoa getPessoa(String nome) {
Cursor cursor = database.query(MySQLiteOpenHelper.TABLE_PESSOA
MySQLiteOpenHelper.allColumns, MySQLiteOpenHelper.COLUMN_NOME + " LIKE '" + nome + "'", 
null, null, null, null);
cursor.moveToFirst();
Pessoa pessoa = new Pessoa();
pessoa.setNome(cursor.getString(0));
pessoa.setEndereco(cursor.getString(1));
cursor.close();
return pessoa;
}
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
e-Dea Jr. - Empresa Júnior da Computação UFC
}
7. Por fim, dentro de sua activity principal, adicione o trecho de código abaixo dentro 
de onCreate() para inserir um dado no banco de dados e depois ler diretamente 
dele e apresentar em um TextView. Obs: Você deve atribuir o id @+id/textview 
para o textview para que o código fundione corretamente.
TextView textView = (TextView)findViewById(R.id.tv);
 
 PessoaDAO issueDAO = new PessoaDAO(this);
 issueDAO.open();
 
 Pessoa p1 = new Pessoa();
 p1.setNome("Andre");
 p1.setEndereco("Rua B");
 
 issueDAO.insertPessoa(p1);
 Pessoa p2 = issueDAO.getPessoa("Andre");
 textView.setText("Nome: " + p2.getNome() + "\n" + "End: " + p2.getEndereco());
 
 issueDAO.close();
O passo a passo seguido anteriormente cria uma aplicação simples que insere um dado no 
banco de dados e depois o lê. Apesar de ser simples, o intuito é que possa ser compreendido 
como interagir com o SQLite.
Universidade Federal do Ceará - UFC Campus do Pici, Av. Humberto Monte, S/N - Centro de Ciências 
Bloco 902, Campus do Pici, Fortaleza - CE| www.edeajr.ufc.br| falecom@edeajr.com| 85 3088-4980
	1. Introdução
	2. Configurando o Ambiente de Desenvolvimento
	3. Criando, Entendendo e Executando Sua Primeira Aplicação
	4. Visão Geral do Ambiente de Desenvolvimento
	5. Activity
	5.1 Trabalhando com Activities
	5.2 Ciclo de vida de uma Activity
	6. Interface com Usuário
	6.1 Layouts básicos
	7. AndroidManifest
	8. Resources
	9. Multimedia
	10. Menu
	11. Componente WebView
	12 . Sensores
	13. Services
	14. Widgets
	15. Armazenamento Interno e Externo
	16. SQLite