CENTRO UNIVERSITÁRIO DA FUNDAÇÃO EDUCACIONAL GUAXUPÉ

JOEL FERNANDO FARIAS

DESENVOLVIMENTO DE UM APLICATIVO PARA SMARTPHONES UTILIZANDO A

LINGUAGEM JAVA E SISTEMA OPERACIONAL ANDROID: SISTEMA DE VENDAS
MOBILE

GUAXUPÉ
2010
 CENTRO UNIVERSITÁRIO DA FUNDAÇÃO EDUCACIONAL GUAXUPÉ

DESENVOLVIMENTO DE UM APLICATIVO PARA SMARTPHONES UTILIZANDO A

LINGUAGEM JAVA E SISTEMA OPERACIONAL ANDROID: SISTEMA DE VENDAS
MOBILE

Trabalho de conclusão de curso apresentado ao

Centro Universitário da Fundação Educacional
Guaxupé como exigência parcial para obtenção
do Bacharelado em Ciência da Computação.
Orientador: Prof. Ms. João Marcelo Ribeiro

GUAXUPÉ
2010
DEDICATÓRIA

Dedico este trabalho a Deus, sem O qual

não existiria e aos meus pais pelo apoio
incondicional durante toda a caminhada
que me trouxe até aqui.
 AGRADECIMENTOS

Ao Prof. João Marcelo Ribeiro pela atenção e orientação neste trabalho.

À minha família pelo apoio dado durante todo o período do curso.

Aos meus amigos, pelo companheirismo que eles têm por mim, sempre dedicando seus
esforços para o meu bem.

À Ordem DeMolay pelos grandes ensinamentos que me foram concedidos.

“Amo a liberdade, por isso deixo as
coisas que amo livres. Se elas voltarem é
porque as conquistei. Se não voltarem é
porque nunca as possuí.”
(John Lennon)
 RESUMO

FARIAS, Joel Fernando. DESENVOLVIMENTO DE UM APLICATIVO PARA

SMARTPHONES UTILIZANDO A LINGUAGEM JAVA E SISTEMA OPERACIONAL
ANDROID: SISTEMA DE VENDAS MOBILE. 2010. 44 f. Trabalho de Conclusão de Curso
(Graduação em Ciência da Computação) - Centro Universitário da Fundação Educacional
Guaxupé. Guaxupé, 2010.

Este trabalho demonstra o processo de desenvolvimento de um aplicativo para smartphones

com sistema operacional Android. É demonstrado o processo de engenharia de software, a
construção das classes e a realização dos testes utilizando-se o aplicativo. São descritas
também as ferramentas e tecnologias usadas, como o plug-in para o emulador Android, que
possibilita a realização dos testes em um ambiente idêntico ao usado em aparelhos reais. Para
a validação do trabalho foi desenvolvido um protótipo de um simples sistema de vendas.

Palavras-chave: Android, dispositivos móveis, Java, smartphone

 LISTA DE FIGURAS

Figura 1 – Máquina Virtual Java ....................................................................................15

Figura 2 – Divisões da Plataforma Java .........................................................................16
Figura 3 – Plataforma Android.......................................................................................18
Figura 4 – Criação de um AVD......................................................................................20
Figura 5 – Emulador Android.........................................................................................20
Figura 6 – Diagrama de caso de uso...............................................................................23
Figura 7 – Diagrama de classes ......................................................................................25
Figura 8 – Diagrama de Seqüência atualiza sistema ......................................................26
Figura 9 – Diagrama de Seqüência solicita pedido ........................................................27
Figura 10 – Diagrama de Seqüência prepara pedido......................................................27
Figura 11 – Diagrama de Seqüência finaliza pedido......................................................28
Figura 12 - Instalação do plug-in ADT para Eclipse......................................................30
Figura 13 - Instalação do plug-in Android .....................................................................30
Figura 14 - Criação do Banco de dados..........................................................................31
Figura 15 - Criação das tabelas via código SQL ............................................................31
Figura 16 - Importando o banco de dados ......................................................................32
Figura 17 - Estrutura de pastas do aplicativo .................................................................32
Figura 18 - Menu Principal.............................................................................................40
Figura 19 - Tela inicial de Clientes ................................................................................41
Figura 20 - Tela Inserir Cliente ......................................................................................41
Figura 21 - Tela Editar ou Excluir Cliente .....................................................................42
Figura 22 - Buscar Cliente..............................................................................................42
 LISTA DE QUADROS

Quadro 1 – Descrição dos casos de uso..........................................................................23

Quadro 2 – Descrição dos métodos do diagrama de classes ..........................................25
 LISTA DE ABREVIATURAS E SIGLAS

API Application Programming Interface

AVD Android Virtual Device
BD Banco de Dados
IDE Integrated Development Environment
JEE Java Enterprise Edition
JME Java Micro Edition
JSE Java Standart Edition
JVM Java Virtual Machine
PDA Personal Digital Assistansts
SDK Software Development Kit
SQL Structured Query Language
UML Unified Modeling Language
USB Universal Serial Bus
XML eXtensible Markup Language
 SUMÁRIO

1 INTRODUÇÃO ....................................................................................................12
1.1 Objetivo.................................................................................................................13
1.2 Estrutura do Trabalho............................................................................................13
2 TÉCNOLOGIAS E FERRAMENTAS .................................................................14
2.1 Java........................................................................................................................14
2.2 Android..................................................................................................................16
2.2.1 Máquina Virtual Dalvik.........................................................................................17
2.2.2 Android SDK.........................................................................................................18
2.2.3 Plataforma .............................................................................................................18
2.2.4 Android Virtual Device (AVD) ............................................................................19
2.2.5 Emulador Android ................................................................................................20
2.3 JUDE, Eclipse e SQLite........................................................................................21
3 DESENVOLVIMENTO DO PROTÓTIPO .........................................................22
3.1 Diagrama de Caso de Uso .....................................................................................22
3.2 Diagrama de Classes .............................................................................................24
3.3 Diagrama de Seqüência.........................................................................................26
4 CODIFICAÇÃO E EXECUÇÃO DO PROTÓTIPO ...........................................29
4.1.1 Instalação de plug-ins............................................................................................29
4.1.2 Criando o banco de dados da aplicação ................................................................30
4.2 Criando a aplicação ...............................................................................................31
4.2.1 Importando o banco de dados ...............................................................................31
4.3 Código Fonte.........................................................................................................33
4.3.1 A Classe R.............................................................................................................33
4.3.2 Menu Principal ......................................................................................................33
4.3.3 Inserção, Alteração, Exclusão e Busca de registros no banco de dados ...............34
4.3.4 Criação de uma lista para visualizar os dados cadastrados ...................................37
4.3.5 Adição de menus e eventos na tela .......................................................................37
4.3.6 Edição e Busca de Registros .................................................................................39
4.3.7 Protótipos de Telas................................................................................................40
5 CONSIDERAÇÕES FINAIS................................................................................43
6 BIBLIOGRAFIA ..................................................................................................44
 12

1. INTRODUÇÃO

A utilização de dispositivos móveis em várias áreas comerciais já é uma realidade em

todo o mundo, apresentando diversos benefícios e tornando cada vez mais fácil e rápido o
processo de cadastros e vendas das empresas. Como a maioria dos aparelhos tem a capacidade
de se conectar a internet, sua localização em relação à empresa não é importante, pois os
dados obtidos em cada transação podem ser enviados on-line, deixando o processo bem mais
ágil e prático. Atualmente, o mercado de aparelhos celulares está crescendo de forma incrível,
chegando à estimativa de que mais de três bilhões de pessoas possuem algum tipo de
dispositivo móvel, ou seja, praticamente um aparelho para cada duas pessoas no mundo.
Hoje, os usuários domésticos procuram aparelhos com recursos como câmeras,
músicas, Bluetooth, acesso a internet, além de boa qualidade de resolução de tela.
O mercado corporativo também está mostrando um crescimento grande, e muitas
empresas já buscam incorporar aplicações móveis em seu dia-a-dia, para facilitar todos os
negócios e integrar as aplicações móveis aos seus sistemas. Dessa forma, aplicações que
executam em um smartphone podem estar conectadas e sincronizadas diretamente com um
servidor confiável na empresa.
A proposta do projeto visa apresentar o desenvolvimento de um pequeno sistema de
vendas para uma loja, utilizando recursos mais práticos para os funcionários e oferecendo
uma solução amigável e simples para os usuários do sistema.
Este projeto definirá todos os cenários possíveis para a completa informatização do
processo de comercialização de uma loja, utilizando dispositivos moveis, sendo que cada
cenário constará de funções simples, para gerar uma maior facilidade aos usuários finais.
Para a validação do projeto será desenvolvido um software que gerenciará todo o
processo, utilizando a tecnologia JAVA desenvolvida pela Sun MicroSystems. Também será
utilizado um pacote de integração com o Sistema Operacional Android, desenvolvido pela
Google, que será o Sistema Operacional do projeto proposto.
Nesse trabalho será mostrado um pouco sobre as tecnologias e ferramentas
empregadas na construção do aplicativo e o desenvolvimento do projeto piloto.
 13

1.1. Objetivo

O objetivo desse trabalho é desenvolver um sistema para controlar as atividades

rotineiras de uma loja que seja capaz de ser operado através de smartphones, facilitando e
tornando mais seguro o processo de cadastros e vendas do estabelecimento.
O objetivo específico do trabalho é organizar os cenários necessários para compor as
várias tarefas efetuadas em uma loja e desenvolver um aplicativo para rodar em dispositivos
móveis utilizando as novas tecnologias existentes no mercado, que auxiliam o programador
no desenvolvimento de um software para celulares.

1.2. Estrutura do Trabalho

Esse trabalho será estruturado em quatro capítulos.

O primeiro capítulo aborda uma introdução e a visão geral do trabalho.
O segundo capítulo explica as ferramentas e tecnologias utilizadas para a validação
do projeto.
O terceiro capítulo mostra todo o processo de engenharia levado em consideração
para o desenvolvimento do projeto
No quarto capítulo é ilustrado todos os passos para a criação da aplicação em termos
de banco de dados, configuração de ambiente de programação e a codificação, com exemplos
das telas criadas.
 14

2. TECNOLOGIAS E FERRAMENTAS

O desenvolvimento de aplicativos para dispositivos móveis já é bastante conhecido e

difundido no mundo, mas não é de tão fácil execução devido à grande variedade de
tecnologias empregadas na fabricação destes dispositivos tais como memória, processadores,
interfaces de rede e interfaces de entrada e saída. É um grande desafio se projetar uma
aplicação para dispositivos móveis, tendo em vista as varias limitações que este tipo de
dispositivos possui, tais como pequena capacidade de processamento, pouca memória,
tamanho de tela reduzido, entre outros. (FURGERI, 2006)
Algumas das tecnologias e ferramentas utilizadas para o desenvolvimento do
aplicativo serão apresentadas abaixo.

2.1. Java

A tecnologia Java foi desenvolvida e disponibilizada pela Sun em 1994, tornando-se

muito popular. A Sun desenvolveu essa tecnologia com o intuito de criar um tipo de
linguagem de programação que pudesse ser executada em qualquer tipo de sistema
computacional para diversos hardwares como mainframes, desktops, notebooks, Personal
Digital Assistansts (PDAs), celulares, dispositivos eletrônicos de carros e de eletrodomésticos
e cartões inteligentes. Essa característica foi primordial para que a linguagem Java se tornasse
tão popular. Com esse sucesso, a utilização dessa tecnologia tornou-se muito grande no meio
empresarial e acadêmico. Assim, a maioria das empresas fabricantes de dispositivos móveis,
principalmente celulares, disponibiliza em seus produtos a plataforma JME para execução de
programas desenvolvidos na linguagem Java. (JOHNSON, 2007)
O funcionamento da linguagem é bem simples. Quando o código-fonte é compilado,
gera-se outro arquivo chamado bytecode, que é lido por um interpretador conhecido como
Maquina Virtual Java (Java Virtual Machine – JVM). Essa maquina virtual traduz o bytecode,
passando instruções para uma linguagem de máquina compatível com o processador utilizado
pelo dispositivo. Com isso, pode-se utilizar o mesmo código-fonte e executar o mesmo
bytecode em diversos sistemas operacionais, desde que possuam uma JVM. (FURGERI,
2006)
A figura 1 mostra como é feita a compilação e tradução do código-fonte pela
máquina virtual:
 15

Figura 1 – Máquina Virtual Java

Fonte: http://img.viralpatel.net/2008/12/java-program-execution.png (27/06/2010).

A linguagem Java é dividida em quatro plataformas:

• Java Enterprise Edition (JEE ou J2EE) - voltada para aplicações corporativas.
É a plataforma que possui mais funcionalidades e recursos entre todas as
plataformas;
• Java Standard Edition (JSE ou J2SE) - utilizada em estações de trabalho
comuns como desktops e notebooks;
• Java Micro Edition(JME ou J2ME) – utilizada para desenvolvimento de
aplicações para dispositivos móveis;
• Java Card é a plataforma que possui menos recursos de todas, ela é utilizada
em cartões inteligentes (smart cards). (JOHNSON, 2007)
A figura a seguir mostra como a plataforma Java é dividida, mostrando cada uma de
suas plataformas e a máquina virtual responsável pela compilação e tradução dos códigos-
fonte gerados por elas:
 16

Figura 2 – Divisões da Plataforma Java

Fonte:
http://2.bp.blogspot.com/_p0hb9T_C6qw/R5CjE5gU_1I/AAAAAAAAABE/al_PjO_euno/s400/a+plataforma+ja
va.JPG (27/06/2010).

2.2. Android

Nos dias atuais, as empresas e os desenvolvedores estão em busca de uma plataforma

moderna e ágil para o desenvolvimento de aplicações coorporativas para auxiliar em seus
negócios. Os usuários comuns, entretanto, buscam um celular com um visual elegante e
moderno, de fácil navegação e com muitos recursos. (LECHETA, 2010)
Pensando nisso, o grupo Open Handset Alliance, liderado pela Google e formado por
algumas das maiores empresas do mercado de telefonia, como a LG, Motorola, Samsung, T-
Mobile, entre outros, buscou criar uma plataforma, de código aberto, para atender a todas as
expectativas e tendências do mercado atual. (ROGERS, 2009)
O objetivo principal desse grupo é definir uma plataforma única e aberta para
celulares para deixar os consumidores mais satisfeitos com o produto final, além de criar uma
plataforma moderna e flexível para desenvolvimento de aplicações coorporativas. O resultado
dessa união resultou na criação da plataforma Android. (ROGERS, 2009)
O Android é uma plataforma de desenvolvimento para aplicativos móveis, como
smartphones, e contêm um sistema operacional baseado em Linux, com uma interface visual
rica, várias aplicações já instaladas e ainda um ambiente de desenvolvimento bastante
poderoso, inovador e flexível. Também é possível usar a linguagem Java para desenvolver as
aplicações, usando todos os recursos que a linguagem dispõe. (LECHETA, 2010)
 17

A licença do Android é flexível e permite que cada fabricante possa realizar

alterações no código-fonte para melhorar a desempenho dos seus produtos, sem ter a
necessidade de compartilhar essas alterações com ninguém. (LECHETA, 2010)
Por ser de código aberto, as melhoras no Android são muito favorecidas, uma vez
que os desenvolvedores de todo o mundo podem contribuir para seu código fonte,
adicionando novas funcionalidades e corrigindo suas falhas.
A arquitetura do Android também é bastante flexível, sendo possível integrar
aplicações nativas com sua aplicação ou até mesmo substituí-las por uma criada pelo usuário,
possibilitando, assim, uma integração rápida, de maneira simples. Foi pensando nessa
integração que a arquitetura do Android foi criada. (LECHETA, 2010)
Outro ponto que deve ser observado é que seu sistema operacional é baseado em
Linux, e ele mesmo se encarrega de gerenciar a memória e os processos, permitindo que
diversas aplicações possam ser executadas ao mesmo tempo. Cada aplicativo dispara um novo
processo, podendo alguns deles exibir alguma tela para o usuário e outras rodar em segundo
plano. O kernel 2.6 do Linux, em que o Android foi baseado, é responsável por realizar todo o
controle de memória. Caso seja necessário, o próprio sistema operacional pode encerrar
algum processo, para liberar memória e recursos. No Android cada aplicação é executada em
um único processo, que possui um thread dedicado. (LECHETA, 2010)

2.2.1 Máquina Virtual Dalvik

A linguagem Java é utilizada para construir aplicações para o Android. Em seu

sistema operacional não existe uma máquina virtual Java (JVM). A máquina virtual do
Android é a chamada Dalvik, que é otimizada para execução em dispositivos móveis.
(ROGERS, 2009)
As aplicações normalmente utilizam todos os recursos da linguagem Java, mas
depois que o bytecode (.class) é compilado, ele é convertido para o formato Dalvik Executable
(.dex), representando a aplicação compilada. Os arquivos .dex e outros recursos, como
imagens, são compactados em um arquivo com a extensão Android Package File (.apk),
representando a aplicação final, pronta para ser executada. (ROGERS, 2009)
Na figura abaixo é possível ver como é distribuída a plataforma Android, desde o
kernel até a aplicação final.
 18

Figura 3 – Plataforma Android

Fonte: http://www.ibm.com/developerworks/br/library/os-Android-devel/fig02.gif

2.2.2 Android SDK (Software Development Kit)

O Android SDK é o software utilizado para desenvolver aplicações no Android.

Possui um emulador para simular o celular, ferramentas utilitárias e uma API completa para a
linguagem Java, com todas as classes necessárias para desenvolver as aplicações.
(LECHETA, 2010)
Mesmo sendo um emulador que pode ser executado com um aplicativo comum,
existem plug-ins para algumas IDEs, que visam integrar o ambiente de desenvolvimento Java
com o emulador, sendo possível iniciar o emulador de dentro da IDE. Também é possível
utilizar um celular real na porta USB do computador para executar diretamente do aparelho,
facilitando muitos os testes. Só é necessário que o driver USB do celular esteja instalado no
computador. (LECHETA, 2010)

2.2.3 Plataforma

Com a existência de vários aparelhos Android no mercado, possivelmente cada um

deles pode conter uma versão diferente do sistema operacional.
No Android, a versão do sistema operacional é conhecida como plataforma. Cada
plataforma possui um código identificador, chamado de API Level. A lista a seguir mostra a
relação entre o código API Level e sua plataforma correspondente:
• API Level 1 – Plataforma Android 1.0
• API Level 2 – Plataforma Android 1.1
 19

• API Level 3 – Plataforma Android 1.5

• API Level 4 – Plataforma Android 1.6
• API Level 5 – Plataforma Android 2.0
• API Level 6 – Plataforma Android 2.0.1
• API Level 7 – Plataforma Android 2.1
• API Level 8 – Plataforma Android 2.2
A API Level é muito importante, uma vez que, em cada aplicação desenvolvida, é
necessário definir qual serão os celulares alvos. (LECHETA, 2010)

2.2.4 Android Virtual Device (AVD)

A configuração virtual de um celular Android foi criada a partir do SDK 1.5 para que
o emulador pudesse simular exatamente a configuração de um celular real, com a mesma
plataforma do sistema operacional, resolução de tela e todas as outras configurações.
A criação de uma configuração virtual é importante para se criar um ambiente de
desenvolvimento próximo ao de um celular real. Sendo assim, devem-se analisar quais APIs
utilizar e verificar se o celular que vamos testar é compatível com a versão testada em
desenvolvimento.
Deve-se ficar atento à qual API utilizar, pois se uma API muita recente for escolhida
na criação do aplicativo, a aplicação pode não funcionar em celulares que não tenham tal
plataforma instalada.
A figura a seguir mostra a tela para criação de um AVD:
 20

Figura 4 – Criação de um AVD

Fonte: Elaborada pelo autor

Deve-se definir um nome para o AVD, qual API será utilizada, o tamanho do cartão
de memória, qual será o modelo interface e o hardware. Essas configurações são as mesmas
usadas por um aparelho real.

2.2.5 Emulador Android

A figura a seguir mostra a interface do emulador do Android:

Figura 5 – Emulador Android

Fonte: Elaborada pelo autor

 21

2.3. JUDE, Eclipse e SQLite

A JUDE ou Java and UML (Unified Modeling Language) Developer Environment é

uma IDE para modelagem de dados grátis. Ela torna possível a elaboração de modelagens de
dados complexas, é de fácil entendimento e usabilidade e exibe seus dados de forma clara
para o usuário.
Eclipse é uma IDE desenvolvida em Java, com código aberto para a construção de
programas de computador. O projeto Eclipse foi iniciado na IBM que desenvolveu a primeira
versão do produto e doou-o como software livre para a comunidade. Hoje, o Eclipse é a IDE
Java mais utilizada no mundo. Possui como características marcantes o uso da SWT e não do
Swing como biblioteca gráfica, a forte orientação ao desenvolvimento baseado em plug-ins e
o amplo suporte ao desenvolvedor com centenas de plug-ins que procuram atender as
diferentes necessidades de diferentes programadores. Com o uso de plug-ins, pode ser usado
não só para desenvolver em Java, mas também em C/C++++, PHP, ColdFusion e até mesmo
Python. (LUCKOW, 2010)
O SQLite é uma ferramenta que permite com que desenvolvedores possam
armazenar os dados de suas aplicações em tabelas e manipular esses dados através de
comandos SQL. A diferença é que tudo isso pode ser feito sem que seja preciso acessar um
SGBD. Devido a sua simplicidade e eficiência, o SQLite está se tornando cada vez mais
popular, especialmente entre as pessoas que programam nas linguagens PHP e C / C++.
 22

3. DESENVOLVIMENTO DO PROTÓTIPO

Para este trabalho, um protótipo será desenvolvido para a validação do mesmo. Neste
capítulo, todo o desenvolvimento da engenharia de software do projeto será descrito: casos de
uso, diagrama de classes e diagramas de seqüência.
Todo o processo de desenvolvimento vai se basear na seguinte proposta de descrição
do projeto:
“Uma loja de vendas deseja informar seu negócio. Para isso, os proprietários
solicitaram o desenvolvimento de um sistema que lhe forneça informações necessárias para
tomadas de decisão. O processo de funcionamento do SisVendasMobile pode ser descrito da
seguinte forma:
Quando o cliente vai efetuar a compra, é verificado se ele é cliente através de
smartphones que os funcionários usam para anotar os pedidos, caso não seja, ele é cadastrado
na hora, fornecendo seus dados. Esses dados serão utilizados para futuras consultas.
Os pedidos serão cadastrados e automaticamente salvos no banco de dados do
sistema. Nesses pedidos constará o código do pedido, nome do cliente, nome do funcionário,
data e valor total. Em cada pedido, os itens do pedido podem ser inclusos a qualquer hora,
desde que o pedido ainda esteja aberto. Conforme cada item for adicionado, o preço total do
produto será automaticamente alterado.
Quando o cliente pede para finalizar seu pedido, uma nota é gerada e caso o valor
total do seu pedido esteja acima de um valor estipulado pelo sistema, ele ganhará um
desconto.
Os proprietários definem uma quantidade mínima dos produtos em estoque. Abaixo
dessa quantidade mínima o próprio sistema emite um aviso comunicando que o produto está
em falta.
Os proprietários podem fazer consultas de clientes, funcionários, pedidos, produtos e
fornecedores. As consultas de clientes, funcionários, produtos e clientes são feitas pelo nome
e a consulta de pedido será feita pelo número do pedido. ”

3.1. Diagrama de Caso de Uso

“Um diagrama de caso de uso é um diagrama que mostra um conjunto de casos de

uso e atores e seus relacionamentos.” (BOOCH, 2005, p.243)
 23

Utiliza-se esse diagrama para organizar e modelar o comportamento de um sistema

exibindo a visão externa do mesmo. O diagrama de caso de uso é representado na figura 6.

Figura 6 – Diagrama de caso de uso

Fonte: Elaborado pelo autor.

No quadro a seguir, são exibidas as descrições dos casos de uso

Quadro 1 – Descrição dos casos de uso.

Caso de Uso Descrição
Atualiza Sistema O funcionário, ao abrir as atividades da loja,
verificará se existe algum produto novo na
loja ou se alguma entrega foi feita,
atualizando assim os dados referentes aos
produtos. Verifica também se existe algum
funcionário ou fornecedor novo.
Novos Cadastros Se existir algum produto, funcionário ou
fornecedor novo, esses serão cadastrados e os
dados salvo em uma base de dados.
Solicita Pedido O cliente chega à loja e efetua o seu pedido,
passando seus dados e os produtos que deseja
 24

comprar, informando a quantidade de cada

um deles.
Novo cliente Se na hora de efetuar o pedido, o cliente
ainda não estiver cadastrado, o funcionário
providenciará para que o cadastro seja feito,
solicitando ao cliente seus dados pessoais.
Esses dados serão salvos em uma base de
dados.
Prepara Pedido O funcionário verifica se nenhum dos
produtos que o cliente pediu está em falta.
Caso algum esteja, uma notificação é emitida
solicitando uma nova reposição. Se tudo
estiver OK, o pedido é processado.
Atende Pedido Os produtos que o cliente pediu serão
entregues a ele e, caso ele queira, poderá
incluir novos itens. A conta total é atualizada
a cada item adicionado.
Finaliza Pedido O pedido é finalizado e a conta total é
passada para o cliente.
Fonte: Elaborado pelo autor.

3.2. Diagrama de Classes

“Um diagrama de classe é um diagrama que mostra um conjunto de classes,

interfaces e colaborações e seus relacionamentos. Graficamente, um diagrama de classes é
uma coleção de vértices e arcos.” (BOOCH, 2005, p.108)
Os diagramas de classes são os mais comuns em sistemas de modelagem orientados a
objetos. Eles proporcionam uma visão estática do projeto de um sistema, exibindo seus
objetos e relacionamentos. A figura 7 mostra o diagrama de classe.
 25

Figura 7 – Diagrama de Classes

Fonte: Elaborado pelo autor.

No quadro abaixo, será dada uma breve explicação para os métodos das classes do
diagrama de classes.

Quadro 2 – Descrição dos métodos do diagrama de classes

Métodos Descrição
adicionar_func(), adicionar_cli(), Métodos para a inserção de funcionários,
adicionar_prod(), adicionar_forn(), clientes, produtos, fornecedores e pedidos,
adicionar_ped() respectivamente.
excluir_func(), excluir_cli(), Métodos para exclusão de funcionários,
excluir_prod(),excluir_forn(), excluir_ped() clientes, produtos, fornecedores e pedidos,
respectivamente.
alterar_func(), alterar_cli(), alterar_prod(), Métodos para alteração de funcionários,
alterar_forn(), alterar_ped() clientes, produtos, fornecedores e pedidos,
respectivamente.
consultar_func(), consultar_cli(), Métodos para consulta de funcionários,
consultar_prod(), consultar_forn, clientes, produtos, fornecedores e pedidos,
consultar_ped() respectivamente.
 26

concluir_ped() Método para finalizar pedido. Quando

chamado encerra o pedido.
incluiritem_pedido() Método para incluir itens ao pedido. Pode ser
chamada a qualquer hora na tela de pedido,
desde que o mesmo ainda não tenha sido
finalizado.
Fonte: Elaborado pelo autor.

3.3. Diagrama de Seqüência

“Um diagrama de interação ou seqüência mostra um comportamento que

compreende um conjunto de mensagens trocadas entre um conjunto de objetos em
determinado contexto para a realização de um propósito. Uma mensagem é a
especificação de uma comunicação entre objetos, a qual contém informações
relacionadas ao que se refere ao que espera resultar dessa atividade.” (BOOCH,
2005, p.213)

Este diagrama exibe o processo dinâmico de um sistema exibindo as mensagens

transmitidas entre os objetos e seu tempo de vida. Geralmente existe pelo menos um diagrama
de seqüência para cada caso de uso.
A seguir, seguem os diagramas de seqüência e uma descrição de cada um deles.

Figura 8 – Diagrama de seqüência atualiza sistema

Fonte: Elaborado pelo autor.

 27

A Figura 8 mostra o diagrama de seqüência para o caso de uso para atualizar o

sistema na abertura da loja. O funcionário faz a verificação de produtos, funcionários e
fornecedores. Caso encontre algum novo, já efetua o cadastro, atualizando, assim, o sistema.

Figura 9 – Diagrama de Seqüência solicita pedido

Fonte: Elaborado pelo autor.

A Figura 9 traz o diagrama de seqüência solicita pedido. Quando o cliente chega à

loja para efetuar seu pedido é verificado se ele é cliente. Caso não seja, ele é cadastrado,
podendo, então, efetuar seu pedido normalmente.

Figura 10 – Diagrama de Seqüência prepara pedido

Fonte: Elaborado pelo autor

A Figura 10 traz o diagrama de seqüência prepara pedido. Nesse caso de uso, o

funcionário já fez o cadastrado do pedido e, agora, vai inserir os itens pedidos. É feita uma
verificação para se ter certeza que o produto está disponível em estoque. Se estiver normal, os
itens são adicionados e a preço total do pedido é atualizado. Caso algum produto esteja abaixo
da quantidade mínima, uma notificação é gerada informando da situação e solicitando um
novo pedido para um dos fornecedores.
 28

Figura 11 – Diagrama de Seqüência finaliza pedido

Fonte: Elaborado pelo autor.

A Figura 11 mostra o diagrama de seqüência para o caso de uso finaliza pedido.

Nesse caso, o cliente pede para finalizar seu pedido. O valor da conta é verificado e, caso
esteja acima de um valor estipulado pelo sistema, recebe um desconto. Logo após, o status do
pedido é alterado para finalizado.
 29

4. CODIFICAÇÃO E EXECUÇÃO DO PROTÓTIPO

Nesse capítulo, será detalhado todo o processo de codificação e execução do

aplicativo, detalhando-se as classes utilizadas, métodos e ações necessárias para o
desenvolvimento da aplicação. Também era exemplificada a instalação dos plug-ins
necessários para a execução do emulador pela IDE, além da criação e exportação do banco de
dados.

4.1.1 Instalação de plug-ins

Para a criação do projeto, será utilizada a IDE Eclipse, como já foi mencionado
acima. Nesse subitem, ilustra-se a maneira como deve ser feita configuração para que o
aplicativo possa executar corretamente.
Para a criação de projetos do tipo Android é necessário fazer a instalação de um plug-
in fornecido pelo Google. A instalação desse plug-in torna os testes no emulador mais fácil de
serem executados. É necessário fazer o download desse plug-in. Isso pode ser feito através do
site http://developer.android.com/sdk/eclipse-adt.html. Nesse projeto foi instalada a versão
ADT 0.9.9.
Depois de baixar o plug-in, basta iniciar o Eclipse, navegar até o menu Help > Install
New Software. Na janela de instalação deve-se clicar no botão Add, depois no botão Archive e
selecionar o arquivo ADT-versao.zip que foi baixado. Preencha o campo nome com um texto
que possa identificar a instalação. Assim, os plug-ins a serem instalados podem ser
visualizados na janela. Então é só selecionar e seguir em frente até a última tela, quando se
deve aceitar a licença e finalizar, iniciando a instalação. A figura 12 mostra a configuração do
site para instalar o plug-in. Na figura 13, são mostrados quais são os plug-ins disponíveis na
versão do ADT escolhida. Para fazer o download, é necessário selecioná-los, assim, a própria
IDE se conecta à Internet, baixando as informações necessárias e instalando da maneira
correta.
 30

Figura 12 – Instalação do plug-in ADT para Eclipse

Fonte: Elaborado pelo autor.

Figura 13 – Instalação do plug-in Android

Fonte: Elaborado pelo autor

4.1.2 Criando o banco de dados da aplicação

O banco de dados (BD) da aplicação será criado utilizando o software SQLite Expert
Personal 3, que é um software para criação de BD bem simples.
Para criar o BD, é necessário informar o local onde o arquivo será salvo, na linha
Database File, um apelido na linda Database Alias, a codificação, o tamanho da página e o
vácuo automático. Esse processo é demonstrado na figura 14.
 31

Figura 14 – Criação do Banco de dados

Fonte: Elaborado pelo autor

Em seguida, criar as tabelas usadas na aplicação. No caso desse aplicativo, as tabelas
criadas serão a tabela cliente e a tabela produtos. Na figura 15, são mostrados os comandos
SQL para a criação das respectivas tabelas:

Figura 15 – Criação das tabelas via código SQL

Fonte: Elaborado pelo autor

Basta clicar no botão Execute SQL que as tabelas serão criadas na database, ficando
prontas para serem importadas pelo aplicativo Android.

4.2 Criando a aplicação

Para criar o projeto, acesse o menu File > New Project > Android Project. Na tela de
adição do novo projeto deve-se especificar o nome do projeto, o local onde será salvo, a
Plataforma (API) utilizada, o nome do pacote de classes, o nome da Activity, e a versão do
SDK utilizado (deve ser a mesma configurada no AVD). Feito isso, deve-se ir ao menu File >
Run as > Android Application para a aplicação ser instalada no emulador.

4.2.1 Importando o banco de dados

Para importar o banco de dados criado com a ajuda do SQLite, deve-se navegar até o
menu Window > Open Perspective > DDMS
 32

Na janela File Explorer, navegar até a pasta /data/data/app.cliente/databases e enviar

o arquivo que foi salva no caminho c:/database/vendasDB para a pasta do emulador. A figura
16 exemplifica esse processo:
Figura 16 – Importando o banco de dados

Fonte: Elaborado pelo autor

A estrutura do projeto criado é exemplificada na figura 17, onde todas as pastas do

projeto são mostradas:

Figura 17 – Estrutura de pastas do aplicativo

Fonte: Elaborado pelo autor

Na pasta src estão todas as classes Java do projeto. Na pasta gen, está a classa R.java.
Na pasta assets ficam os arquivos personalizados, com uma fonte customizada. Na pasta res
estão os recursos da aplicação. Dentro da pasta res estão as pastas drawable, com as imagens
usadas na aplicação, layout, com os arquivos para a construção das telas e values, que contem
arquivos para internacionalização da aplicação.
 33

4.2.2 Código Fonte

Nesse tópico do trabalho será detalhada toda a parte de codificação da aplicação,

com explicações mais profundas sobre métodos e classes utilizadas, além de exemplos da
parte visual, as telas, e como elas foram criadas. As classes utilizadas para as entidades
CLIENTES e PRODUTOS possuem a mesma estrutura, mudando apenas os parâmetros
passados: nas classes referentes à cliente, passa-se cliente, e nas classes referentes à produto,
passa-se produto.
Como as estruturas são basicamente iguais, nesse trabalho serão explicadas apenas as
classes e métodos de uma entidade.

4.2.2.1 A Classe R

Antes de explicar como cada classe da aplicação funciona, é necessário falar sobre a
classe R.java, que será de grande ajuda para a construção do aplicativo. Ela é criada
automaticamente pelo plug-in do Eclipse e não deve ser alterada manualmente. Todas as
modificações necessárias são feitas quanto algum recurso do projeto é alterado. Esses
recursos, no caso do aplicativo proposto para esse trabalho, são arquivos eXtensible Markup
Language (XML), com as telas da aplicação. (LECHETA, 2010)

4.2.2.2 Menu Principal

Na classe implementada para o menu principal, uma classe pública criada com o
nome “menuprincipal” e herda as funcionalidades de uma Activity (geralmente uma tela). São
criados três campos inteiros que recebem um inteiro como valor, para posteriormente ser feita
uma escolha, onde, dependendo do campo escolhido, será aberto um menu para clientes ou
produtos ou, então, sair da aplicação.
public class MenuPrincipal extends Activity {

protected static final int CLIENTES = 1;

protected static final int PRODUTOS = 2;
protected static final int SAIR = 3;

…}
 34

4.2.2.3 Inserção, Alteração, Exclusão e Busca de registros no banco de dados

Para inserir registros no banco de dados, devemos criar um objeto do tipo

android.content.ContentValues com as informações necessárias , que funciona com uma
tabela, com chave e valor. Depois de criar esse objeto, basta chamar o método
SQLiteDatabase.insert(tabela, valores), onde tabela é o nome da tabela e valores são os
registros que serão inseridos. A seguir, o trecho do código onde é feita a inserção de um novo
registro:

// Insere um novo cliente

public long inserir(Cliente cliente) {
ContentValues values = new ContentValues();
values.put(Clientes.NOME, cliente.nome);
values.put(Clientes.ENDERECO, cliente.endereco);
values.put(Clientes.TELEFONE, cliente.telefone);
values.put(Clientes.CPF, cliente.cpf);

long id = inserir(values);
return id;
}

// Insere um novo cliente

public long inserir(ContentValues valores) {
long id = db.insert(NOME_TABELA, "", valores);
return id;
}

Para efetuar a alteração de um registro, utiliza-se o método

SQLiteDatabase.update(tabela, valores, where, whereArgs), onde tabela é o nome da tabela,
valores são os valores que serão atualizados, where é a cláusula utilizada para identificar o
registro e whereArgs é um Array com os parâmetros necessários. O código do registro pode
ser utilizado para identificar o registro que deve ser atualizado. O trecho de código para a
atualização de um registro é mostrado a seguir:
 35

// Atualiza o cliente no banco. O id do cliente é utilizado.

public int atualizar(Cliente cliente) {
ContentValues values = new ContentValues();
values.put(Clientes.NOME, cliente.nome);
values.put(Clientes.ENDERECO, cliente.endereco);
values.put(Clientes.TELEFONE, cliente.telefone);
values.put(Clientes.CPF, cliente.cpf);

String _id = String.valueOf(cliente.id);

String where = Clientes._ID + "=?";
String[] whereArgs = new String[] { _id };
int count = atualizar(values, where, whereArgs);
return count;
}

// Atualiza o cliente com os valores abaixo

// A cláusula where é utilizada para identificar o cliente a ser
atualizado
public int atualizar(ContentValues valores, String where, String[]
whereArgs) {
int count = db.update(NOME_TABELA, valores, where,
whereArgs);
Log.i(CATEGORIA, "Atualizou [" + count + "] registros");
return count;
}

Para a exclusão de registros, o método SQLiteDatabase .delete(tabela, where,

whereArgs) é utilizado. Os parâmetros são iguais aos exemplificados para a atualização do
registro. A codificação para essa rotina é mostrada abaixo:

// Deleta o cliente com o id fornecido

public int deletar(long id) {
String where = Clientes._ID + "=?";

String _id = String.valueOf(id);

String[] whereArgs = new String[] { _id };

int count = deletar(where, whereArgs);

return count;
}

// Deleta o cliente com os argumentos fornecidos

public int deletar(String where, String[] whereArgs) {
int count = db.delete(NOME_TABELA, where, whereArgs);
Log.i(CATEGORIA, "Deletou [" + count + "] registros");
return count;
}

Para efetuar a busca à um registro, o método SQLiteDatabase.query(distinct, tabela,

colunas, seleção, selecaoArgs, groupBy, orderBy). Na aplicação, passamos como nulos os
campos distinct, selecaoArgs, groupBy e orderBy, pois os mesmos não interferem na busca. A
 36

busca é feita de duas maneiras: uma buscando um único registro, em que um objeto do tipo
android.database.Cursor é retornado com os valores do registro desejado, e outra buscando
todos os registros, onde o mesmo objeto é retornado, mas com uma lista de todos os registros.
// Busca o cliente pelo id
public Cliente buscarCliente(long id) {
// select * from cliente where _id=?
Cursor c = db.query(true, NOME_TABELA, Cliente.colunas,
Clientes._ID + "=" + id, null, null, null, null, null);

if (c.getCount() > 0) {
// Posicinoa no primeiro elemento do cursor
c.moveToFirst();
Cliente cliente = new Cliente();
// Lê os dados
cliente.id = c.getLong(0);
cliente.nome = c.getString(1);
cliente.endereco = c.getString(2);
cliente.telefone = c.getString(3);
cliente.cpf = c.getString(4);
return cliente;
}

return null;
}
// Retorna uma lista com todos os clientes
public List<Cliente> listarClientes() {
Cursor c = getCursor();

List<Cliente> clientes = new ArrayList<Cliente>();

if (c.moveToFirst()) {

// Recupera os índices das colunas

int idxId = c.getColumnIndex(Clientes._ID);
int idxNome = c.getColumnIndex(Clientes.NOME);
int idxEndereco = c.getColumnIndex(Clientes.ENDERECO);
int idxTelefone = c.getColumnIndex(Clientes.TELEFONE);
int idxCpf = c.getColumnIndex(Clientes.CPF);

// Loop até o final

do {
Cliente cliente = new Cliente();
clientes.add(cliente);

// recupera os atributos de cliente

cliente.id = c.getLong(idxId);
cliente.nome = c.getString(idxNome);
cliente.endereco = c.getString(idxEndereco);
cliente.telefone = c.getString(idxTelefone);
cliente.cpf = c.getString(idxCpf);

} while (c.moveToNext());
}

return clientes;
}
 37

A classe RepositorioCliente usa uma classe Cliente para armazenar os valores de

cada cliente e suas constantes para definir os nomes das colunas da tabela cliente.

4.2.2.4 Criação de uma lista para visualizar os dados cadastrados

Abaixo, segue o código que lista todos os cliente já cadastrados assim que a tela
inicial de clientes for chamada:

public class CadastroClientes extends ListActivity {

public static RepositorioCliente repositorio;

private List<Cliente> clientes;

@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
repositorio = new RepositorioCliente(this);
atualizarLista();
}

protected void atualizarLista() {

// Pega a lista de clientes e exibe na tela
clientes = repositorio.listarClientes();
// Adaptador de lista customizado para cada linha de um
cliente
setListAdapter(new ClienteListAdapter(this, clientes));
}

No método onCreate(bundle) é criado um repositório de clientes e no método

atualizarLista(), uma lista é recuperada. O método serListAdapter(adaptador) passa uma
instância da classe CarroListAdapter, para preencher a lista de clientes na tela. Essa lista é
desenhada por um arquivo XML que fica dentro da pasta layout. Nesse arquivo, existem
alguns comandos para a criação de campos de textos na tela do emulador.

4.2.2.5 Adição de menus e eventos na tela

Depois que a explicação básica sobre como criar uma lista de clientes, será
exemplificado como criar um menu com opções para busca e edição, além de alguns eventos
de tela para a lista de clientes
 38

Para criar um menu, basta seguir a mesma linha de raciocínio da criação do menu
principal, onde são criados dois campos que recebem valores inteiros, que serão usados para
um verificação. Caso um for escolhido, executará uma determinada ação, se o outro for
escolhido, outra ação será executada. Veja o trecho de código que mostra exatamente como
isso acontece:
...
protected static final int INSERIR_EDITAR = 1;
protected static final int BUSCAR = 2;
...
public boolean onMenuItemSelected(int featureId, MenuItem item) {
// Clicou no menu
switch (item.getItemId()) {
case INSERIR_EDITAR:
// Abre a tela com o formulário para adicionar
startActivityForResult(new Intent(this,
EditarCliente.class), INSERIR_EDITAR);
break;
case BUSCAR:
// Abre a tela para buscar o cliente pelo nome
startActivity(new Intent(this, BuscarCliente.class));
break;
}
return true;
}

Se INSERIR_EDITAR for escolhido, abrirá a Activity EditarCliente. Caso BUSCAR

for selecionado, a Activity BuscarCliente será iniciada.
Nessa classe também é implementado um método para edição de registros já
inseridos. Quando clicar em um deles, a tela de edição é aberta e assim o registro poderá ser
alterado ou excluído. O trecho abaixo mostra como isso é feito:
protected void onListItemClick(ListView l, View v, int posicao, long id) {
super.onListItemClick(l, v, posicao, id);
editarCliente(posicao);
}

// Recupera o id do cliente, e abre a tela de edição

protected void editarCliente(int posicao) {
// Usuário clicou em algum cliente da lista
// Recupera o cliente selecionado
Cliente cliente = clientes.get(posicao);
// Cria a intent para abrir a tela de editar
Intent it = new Intent(this, EditarCliente.class);
// Passa o id do cliente como parâmetro
it.putExtra(Clientes._ID, cliente.id);
// Abre a tela de edição
startActivityForResult(it, INSERIR_EDITAR);
}
 39

4.2.2.6 Edição e Busca de Registros

Para efetuar a edição de um cliente, a classe EditarCliente é chamada. Nessa classe, o

acesso ao repositório é encapsulado para salvar, excluir ou atualizar um cliente. No método
onCreate(bundle) é feita a verificação para ver se o id do cliente foi informado, para
identificar o cliente que deve ser atualizado. Se o id for passado, significa que uma
atualização será realizada. Se não for passado, um novo cliente será inserido. Veja o código:

Bundle extras = getIntent().getExtras();

// Se for para Editar, recuperar os valores ...
if (extras != null) {

id = extras.getLong(Clientes._ID);

if (id != null) {
// é uma edição, busca o cliente...
Cliente c = buscarCliente(id);
//if( c!=null){
campoNome.setText(c.nome);
campoEndereco.setText(c.endereco);
campoTelefone.setText(c.telefone);
campoCpf.setText(c.cpf);
//}
}

Os métodos salvar() e excluir() informam a constante RESULT_OK para o método

setResult(código, intent), para indicar que um novo cliente foi salvo ou excluído do banco de
dados, atualizando assim a lista
setResult(RESULT_OK, new Intent());

Para a busca de clientes, usa-se a classe a classe BuscarCarro. Essa classe não traz de
nenhum retorno no que diz respeito a parâmetros. Ela simplesmente executa uma busca no
banco de dados para encontrar o cliente pelo seu nome. Se o carro for encontrado, os campos
da tela são preenchidos com as informações restantes. Caso não encontre, uma mensagem de
alerta é exibida na tela.
 40

4.2.2.7 Protótipos de Telas

Nessa seção do trabalho, todas as telas no aplicativo serão apresentadas. Cada tela
dela foi criada através de um código XML, com comandos para inserção de campos de textos
e textos simples
Na figura 18, é mostrada a tela do menu principal
Figura 18 – Menu Principal

Fonte: Elaborado pelo autor

Na figura 19, a tela inicial de clientes é mostrada. Quando essa tela é chamada, uma
lista com os clientes já cadastrados é mostrada. Também são exibidos os menus Inserir
Cliente e Buscar Cliente assim que o botão menu do emulador é pressionado.
 41

Figura 19 – Tela inicial de Clientes

Fonte: Elaborado pelo autor

Na figura 20, a tela para inserir um novo cliente. A figura 21 mostra a tela para editar
ou excluir um cliente, enquanto a figura 22 apresenta a tela de busca de cliente.

Figura 20 – Tela Inserir Cliente

Fonte: Elaborado pelo autor

 42

Figura 21 – Tela Editar ou Excluir Cliente

Fonte: Elaborado pelo autor

Figura 22 – Buscar Cliente

Fonte: Elaborado pelo autor

 43

5. CONSIDERAÇÕES FINAIS

Com o crescente número de celulares sendo vendidos a cada ano e com as novas
tecnologias que estão surgindo, conclui-se que esse mercado de aplicações para dispositivos
móveis ainda é um mercado em plena expansão e com grande potencial lucrativo,
principalmente com softwares que facilitem a vida dos milhões de usuários espalhados pelo
mundo.
O trabalho apresenta um estudo sobre as tecnologias empregadas no
desenvolvimento do protótipo além de apresentar um breve estudo sobre o Sistema
Operacional Android, sistema em que a aplicação foi instalada. Além da construção de um
pequeno aplicativo de vendas, que foi o tema proposto para desenvolvimento da aplicação.
Também são apresentadas as ferramentas utilizadas para o desenvolvimento da
aplicação, desde a elaboração do projeto, utilizando a UML, até a fase de codificação usando
a IDE Eclipse e testes no emulador. Sendo todas essas ferramentas muito úteis e necessárias
ao desenvolvedor, possuindo a vantagem de serem gratuitas.
A escolha do Sistema Operacional Android para o protótipo se deu pelo grande
aumento de consumidores de aparelhos com esse sistema. O sistema Android é open-source
(código-livre) e também baseado em Linux, o que permite que qual pessoa possa fazer
alterações em seu código, visando melhorias.
A codificação das classes do projeto foi feita em Java, uma linguagem orientada a
objetos, que torna a programação mais fácil, devido a possibilidade de reutilização de
códigos. No projeto, existe uma classe chamada R.java, que faz todo o trabalho de montagem
das telas no emulador, pegando os parâmetros criados por códigos XML, que ficam em um
local reservado dentro do projeto. A interface gráfica do aplicativo foi desenvolvida em XML,
utilizando comandos simples para gerar textos e botões.
A proposta principal do trabalho, que era mostrar o funcionamento de uma aplicação
executando no sistema operacional foi cumprida, com o desenvolvimento de uma pequena
aplicação para uma loja. Esse trabalho propiciou um engrandecimento sobre as tecnologias
utilizadas para o desenvolvimento de aplicativos para dispositivos móveis, além do
conhecimento mais profundo sobre a tecnologia Android.
A idéia desse software pode ser aproveita para desenvolvimento de aplicações mais
completas para outros tipos de comércio que queiram utilizar aparelhos Android. Pode-se
melhorar a aplicação implementando idéias que não foram utilizadas no protótipo, como
enviar os dados cadastrados, via wireless, para outro local, geração de relatórios.
 44

6. BIBLIOGRAFIA

BOOCH, Grady; RUMBAUGH, James; JACOBSON, Ivar; UML - Guia do Usuário, Editora
Campus, 2006.

FURGERI, Sérgio; Java 6 – Ensino Didático: Desenvolvendo e Implementando Aplicações,

Editora Érica, 2008.

GONÇALVES, Eduardo Corrêa; SQLite, Muito Prazer!, http://www.devmedia.com.br/post-

7100-SQLite-Muito-Prazer.html (Acesso em 10 de novembro de 2010)

JOHNSON, Thienne M.; Java para Dispositivos Móveis – Desenvolvendo Aplicações com
J2ME, Editora Novatec, 2007.

LECHETA, Ricardo R.; Google Android: aprenda a criar aplicações para dispositivos móveis
com Android SDK, Editora Novatec, 2010.

LUCKOW, Décio Heinzelmann; MELO, Alexandre Altair de. Programação Java para a
Web: Aprenda a desenvolver uma aplicação financeira pessoal com as ferramentas mais
modernas da plataforma Java. Editora Novatec, 2010.

ROGERS, Rick; LOMBARDO, John; MEDNIEKS, Zigurd; MEIKE, Blake;

Desenvolvimento de Aplicações Android: Programação com o SDK do Google, Editora
Novatec, 2009.