UTILIZAÇÃO DE RECURSOS JAVA NA PLATAFORMA ANDROID PARA FACILITAR O PROCESSO DE COMPRA
114
Instituto Superior de Ensino e Pesquisa de Ituiutaba FEIT – Fundação Educacional de Ituiutaba UEMG – Universidade do Estado de Minas Gerais ROBERTO GUIMARÃES DUTRA DE OLIVEIRA UTILIZAÇÃO DE RECURSOS JAVA NA PLATAFORMA ANDROID PARA FACILITAR O PROCESSO DE COMPRA ITUIUTABA 2012
Transcript of UTILIZAÇÃO DE RECURSOS JAVA NA PLATAFORMA ANDROID PARA FACILITAR O PROCESSO DE COMPRA
Instituto Superior de Ensino e Pesquisa de Ituiutaba
FEIT – Fundação Educacional de Ituiutaba
UEMG – Universidade do Estado de Minas Gerais
ROBERTO GUIMARÃES DUTRA DE OLIVEIRA
UTILIZAÇÃO DE RECURSOS JAVA NA PLATAFORMA
ANDROID PARA FACILITAR O PROCESSO DE
COMPRA
ITUIUTABA
2012
ROBERTO GUIMARÃES DUTRA DE OLIVEIRA
UTILIZAÇÃO DE RECURSOS JAVA NA PLATAFORMA
ANDROID PARA FACILITAR O PROCESSO DE
COMPRA
Trabalho de Conclusão de Curso apresentado à
Universidade do Estado de Minas Gerais –
Fundação Educacional de Ituiutaba como pré-
requisito para obtenção parcial de créditos em
Bacharel em Engenharia de Computação.
Orientadora: Prof. Dra. Mônica Rocha Ferreira
de Oliveira
ITUIUTABA
2012
UTILIZAÇÃO DE RECURSOS JAVA NA PLATAFORMA
ANDROID PARA FACILITAR O PROCESSO DE
COMPRA
ROBERTO GUIMARÃES DUTRA DE OLIVEIRA
Professora orientadora:
_______________________________________________________
Prof(a). Dra Mônica Rocha Ferreira de Oliveira
Avaliadores:
_______________________________________________________
Adriana de Souza Guimarães
_______________________________________________________
Saulo Moraes Garcia Júnior
Ituiutaba
2012
AGRADECIMENTOS
A Deus.
Aos meus pais, Samir e Mírian, que sempre me apoiaram, acreditaram e
investiram em mim, e aos meus familiares que sempre me incentivaram.
A minha namorada, Mariana, pelo apoio e compreensão nos momentos difíceis e
pela motivação nas situações em que nada parecia dar certo.
Aos meus colegas de sala pelas tristezas e alegrias compartilhadas durante esses
anos de convivência.
Aos meus professores pelos ensinamentos passados em sala de aula, colaborando
para minha formação profissional, e a minha orientadora, Mônica, pela orientação e
disposição, contribuindo para o desenvolvimento e conclusão deste trabalho.
“Quão melhor é adquirir a sabedoria do
que o ouro! e quão mais excelente é
adquirir a prudência do que a prata!”
Provérbios 16:16
RESUMO
Com a evolução da tecnologia e o mundo globalizado, as atividades diárias parecem
aumentar e se tornarem cada vez mais complexas. Nem sempre é tão simples dispor de
tempo para realizar atividades rotineiras como, por exemplo, ir às compras. Uma
possível solução para simplificar este processo é a integração da tecnologia ao dia a dia.
A evolução dos celulares cresce em grande escala, não somente o número de
consumidores, mas também as tecnologias disponíveis para esses aparelhos.
Tecnologias que antes eram disponíveis apenas para notebooks e computadores, como
as redes sem fio (wireless) alcançam também os celulares, permitindo que eles tenham
uma interação maior com outros dispositivos e também as linguagens de programação
de alto nível, permitindo a construção de aplicativos dos mais variados tipos. O objetivo
deste projeto é facilitar ao máximo o processo de compra realizado pelo cliente, desde
antes de chegar ao comércio até o momento de encontrar a posição dos produtos nas
prateleiras. Para o desenvolvimento do projeto será usada a linguagem de programação
Java e a plataforma de desenvolvimento para dispositivos móveis Android.
Palavras-chave: Android; Java; Tecnologia; Dispositivos móveis.
ABSTRACT
Due to the evolution in technology and to the globalized world, daily activities seem to
have been becoming more and more complicated. It is not always an easy task to
dispose of time to do routine activities, such as, going shopping. A viable solution to
simplify this process is the integration of technology to our daily lives. Mobile phones
evolve at a great speed, not only concerning the number of consumers, but also the
available technologies for those devices. Technologies which used to be available only
for notebooks and desktops computers, such as wireless are also reaching mobile
phones, allowing them to have a greater interaction with other devices as well as to the
high level programming language, enabling the building of the most varied types of
applicatives. The aim of this project is to make the shopping process, the easiest
possible to the consumer from the moment he leaves his house to that moment when he
tries to find the goods on the market’s shelves. For the development of the project both
the programming language Java and the platform for mobile devices Android will be
used.
Key words: Android; Java; Technology; Mobile devices.
LISTA DE FIGURAS
Figura 1 - Arquitetura do NetBeans (HUANG, 2010). .................................................................. 32
Figura 2 - Arquitetura do Eclipse (ECLIPSE, 2007). ...................................................................... 34
Figura 3 - Processo de compilação e interpretação utilizado pelo Java (FREITAS, 2010). .......... 39
Figura 4 - Ciclo de vida de uma thread (RAMOS e TEODOROWITSCH, 2009). ............................ 43
Figura 5 - Arquitetura da plataforma Android (PRADO, 2011). .................................................. 45
Figura 6 – Aplicativo Barcode Scanner (BESTANDROID, 2009). .................................................. 49
Figura 7 - Mapa do Brasil no Google Maps (GOOGLE, 2012). ..................................................... 49
Figura 8 - Cidade de Ituiutaba vista no modo mapa (GOOGLE, 2012). ....................................... 50
Figura 9 - Cidade de Ituiutaba vista no modo satélite (GOOGLE, 2012). .................................... 50
Figura 10 - Cidade de Ituiutaba vista no modo terreno (GOOGLE, 2012). .................................. 51
Figura 11 - Diagrama de caso de uso do servidor. ...................................................................... 56
Figura 12 - Diagrama de caso de uso do cliente. ........................................................................ 64
Figura 13 – Diagrama de sequência do usuário – Efetuar log-in. ............................................... 69
Figura 14 – Diagrama de sequência do usuário – Cadastrar produto. ........................................ 69
Figura 15 - Diagrama de sequência do usuário - Visualizar produto. ......................................... 69
Figura 16 – Diagrama de sequência do usuário - Editar produto. .............................................. 70
Figura 17 - Diagrama de sequência do usuário - Excluir produto. .............................................. 70
Figura 18 - Diagrama de sequência do usuário - Produtos mais buscados. ................................ 71
Figura 19 - Diagrama de sequência do usuário - Abrir/Fechar conexão. .................................... 71
Figura 20 - Diagrama de sequência do administrador – Cadastrar usuário. ............................... 72
Figura 21 - Diagrama de sequência do administrador - Editar usuário. ..................................... 72
Figura 22 - Diagrama de sequência do administrador - Visualizar usuário. ................................ 73
Figura 23 - Diagrama de sequência do administrador - Excluir usuário. .................................... 73
Figura 24 - Diagrama de sequência do administrador - Gerar relatório usuário. ....................... 73
Figura 25 - Diagrama de sequência do cliente - Buscar produto pelo nome. ............................. 74
Figura 26 - Diagrama de sequência do cliente - Buscar produto pelo código de barras. ........... 75
Figura 27 - Diagrama de sequência do cliente - Visualizar produtos mais buscados. ................ 75
Figura 28 - Diagrama de sequência do cliente - Ligar para estabelecimento. ............................ 76
Figura 29 - Diagrama de sequência do cliente – Visualizar mapa. .............................................. 76
Figura 30 - Diagrama de sequência do cliente - Visualizar posição comércio. ........................... 76
Figura 31 - Diagrama de sequência do cliente - Visualizar própria posição................................ 77
Figura 32 - Diagrama de classe do servidor. ............................................................................... 78
Figura 33 - Diagrama de classe do cliente. .................................................................................. 79
Figura 34 - Tela de acesso ao sistema. ........................................................................................ 80
Figura 35 - Acesso ao sistema como administrador. .................................................................. 81
Figura 36 - Acesso ao sistema como usuário comum. ................................................................ 82
Figura 37 - Permitir conexões dos clientes. ................................................................................ 83
Figura 38 - Bloquear conexões dos clientes. ............................................................................... 84
Figura 39 - (a) Tela inicial do software do cliente. (b) Tela escolha de opções. .......................... 88
Figura 40 - (a) Escolha da opção “Buscar pelo Nome”. (b) Inserção do nome do produto. ....... 98
Figura 41 - (a) Escolha do produto. (b) Visualização das informações do produto. ................... 99
Figura 42 - (a) Escolha da opção “Buscar pelo código de barras”. (b) Leitura código de barras.
................................................................................................................................................... 100
Figura 43 - Visualização das informações do produto. ............................................................. 100
Figura 44 - (a) Escolha da opção “Produtos Mais Buscados”. (b) Escolha do produto. ............ 101
Figura 45 - Visualização das informações do produto. ............................................................. 102
Figura 46 - (a) Escolha da opção “Ligar para o Estabelecimento”. (b) Realização da chamada.
................................................................................................................................................... 103
Figura 47 - Escolha da opção “Como Chegar?”. ........................................................................ 104
Figura 48 - (a) Visualização modo satélite. (b) Visualização modo mapa. ................................ 105
Figura 49 - (a) Mapa centralizado no estabelecimento. (b) Mapa centralizado no cliente ...... 106
LISTA DE TABELAS
Tabela 1 - Caso de uso do cliente: efetuar log-in. ....................................................................... 57
Tabela 2 - Caso de uso do cliente: cadastrar produto................................................................. 57
Tabela 3 - Caso de uso do cliente: editar produto. ..................................................................... 58
Tabela 4 - Caso de uso do cliente: visualizar produto. ................................................................ 58
Tabela 5 - Caso de uso do cliente: excluir produto. .................................................................... 59
Tabela 6 - Caso de uso do cliente: Visualizar produtos mais buscados. ..................................... 59
Tabela 7 - Caso de uso do cliente: Abrir/Fechar conexão. .......................................................... 60
Tabela 8 - Caso de uso do administrador: cadastrar usuário. ..................................................... 60
Tabela 9 - Caso de uso do administrador: editar usuário. .......................................................... 61
Tabela 10 - Caso de uso do administrador: visualizar usuário. ................................................... 61
Tabela 11 - Caso de uso do administrador: excluir usuário. ....................................................... 62
Tabela 12 - Caso de uso do administrador: verificar relatório de usuários. ............................... 62
Tabela 13 - Caso de uso do cliente: buscar produto pelo nome. ................................................ 65
Tabela 14 - Caso de uso do cliente: buscar produto pelo código de barras. .............................. 65
Tabela 15 - Caso de uso do cliente: visualizar produtos mais buscados. .................................... 66
Tabela 16 - Caso de uso do cliente: ligar para o estabelecimento. ............................................. 66
Tabela 17 - Caso de uso do cliente: visualizar mapa. .................................................................. 67
Tabela 18 - Caso de uso do cliente: visualizar posição comércio. ............................................... 67
Tabela 19 - Caso de uso do cliente: visualizar própria posição. .................................................. 68
LISTA DE ABREVIATURAS E SIGLAS
ABI – Allied Business Intelligence
ADT – Android Development Tools
AOSP – Android Open Source Project
API – Application Programming Interface
ARPA – Advanced Research Projects Agency
BCPL – Basic Combined Programming Language
BDS – BREW Distribution System
BREW – Binary Runtime Environment for Wireless
CDMA – Code Division Multiple Access
CPU – Central Processing Unit
DDL – Data Definition Language
DEC – Digital Equipment Corporation
DML – Data Manipulation Language
EJB – Enterprise JavaBeans
GPS – Global Positioning System
HP – Hewlett-Packard
HTML – HyperText Markup Language
HTTP – HyperText Transfer Protocol
IBM – International Business Machines
IDE – Integrated Development Environment
iOS – iPhone Operating System
IP – Internet Protocol
JAR – Java Archive
JDK – Java Development Kit
JIT – Just In Time
JMS – Java Messege Service
JVM – Java Virtual Machine
J2EE – Java 2 Enterprise Edition
J2ME – Java 2 Micro Edition
J2SE – Java 2 Standard Edition
MacOS – Macintosh Operating System
MPL – Mozilla Public License
NT – New Technology
OHA – Open Handset Alliance
PC – Personal Computer
PDA – Personal Digital Assistants
PDP-11 – Programmed Data Processors
PHP – Personal Home Page
PUC – Pontifícia Universidade Católica
QR – Quick Response
RMI – Remote Method Invocation
RMS – Record Management System
SDK – Software Development Kit
SGBD – Sistema Gerenciador de Banco de Dados
SPL – Sun Public License
SQL – Structured Query Language
TCP – Transmission Control Protocol
TECGRAF – Grupo de Tecnologia em Computação Gráfica
UDP – User Datagrama Protocol
UML - Unified Modeling Language
UNIX - Uniplexed Information and Computing System
XML – Extensible Markup Language
SUMÁRIO
1 INTRODUÇÃO ................................................................................................................ 16
1.1 Mercado de celulares .............................................................................................................. 17
1.2 Identificação do problema ...................................................................................................... 18
1.3 Objetivos ................................................................................................................................. 18
1.3.1 Objetivo geral ............................................................................................................................ 18
1.3.2 Objetivos específicos ................................................................................................................ 19
1.4 Justificativa ............................................................................................................................. 19
1.5 Organização do trabalho ......................................................................................................... 20
2 ESTADO DA ARTE ........................................................................................................ 21
2.1 Linguagens para dispositivos móveis ....................................................................................... 21
2.1.1 Lua ............................................................................................................................................. 21
2.1.2 C/C++ ......................................................................................................................................... 22
2.1.3 Python ....................................................................................................................................... 23
2.1.4 Java ........................................................................................................................................... 23
2.2 Plataformas de desenvolvimento ............................................................................................ 24
2.2.1 Android ...................................................................................................................................... 25
2.2.2 Symbian..................................................................................................................................... 25
2.2.3 BREW......................................................................................................................................... 26
2.2.4 Windows Mobile ....................................................................................................................... 27
2.3 Conclusão ................................................................................................................................ 28
3 REFERENCIAL TEÓRICO ............................................................................................. 29
3.1 IDE ........................................................................................................................................... 29
3.1.1 NetBeans ................................................................................................................................... 29
i. Histórico .................................................................................................................................... 30
ii. Arquitetura................................................................................................................................ 31
iii. Utilização................................................................................................................................... 32
3.1.2 Eclipse ....................................................................................................................................... 33
i. Histórico .................................................................................................................................... 33
ii. Arquitetura................................................................................................................................ 34
iii. Utilização................................................................................................................................... 35
3.2 Java ......................................................................................................................................... 36
3.2.1 Plataformas ............................................................................................................................... 36
3.2.2 Características ........................................................................................................................... 37
3.2.3 JVM ........................................................................................................................................... 38
3.2.4 Garbage Collection .................................................................................................................... 39
3.2.5 Sockets ...................................................................................................................................... 40
3.2.6 Threads ..................................................................................................................................... 42
3.3 Google Android ....................................................................................................................... 44
3.3.1 Arquitetura................................................................................................................................ 44
3.3.2 Classes Activity e View .............................................................................................................. 46
3.3.3 Classe R e Arquivo AndroidManifest ......................................................................................... 47
3.3.4 XML ........................................................................................................................................... 47
3.3.5 Barcode Scanner ....................................................................................................................... 48
3.4 Google Maps ........................................................................................................................... 49
3.5 Banco de Dados ....................................................................................................................... 51
3.5.1 SQLite ........................................................................................................................................ 52
3.6 Conclusão ................................................................................................................................ 53
4 ESTUDO DE CASOS ....................................................................................................... 55
4.1 Diagrama de caso de uso ......................................................................................................... 55
4.2 Diagrama de sequência ........................................................................................................... 68
4.3 Diagrama de classe .................................................................................................................. 77
4.4 Desenvolvimento do software servidor ................................................................................... 80
4.4.1 Acesso ao sistema ..................................................................................................................... 80
4.4.2 Utilização das threads ............................................................................................................... 82
4.4.3 Transmissão dos dados via sockets ........................................................................................... 85
4.5 Desenvolvimento do software do cliente ................................................................................ 87
4.5.1 Interface do software ................................................................................................................ 88
4.5.2 Transmissão dos dados via sockets ........................................................................................... 89
4.5.3 Leitura do código de barras ...................................................................................................... 90
4.5.4 Armazenamento do histórico de buscas ................................................................................... 92
4.5.5 Realização de ligações ............................................................................................................... 94
4.5.6 Mapas e GPS ............................................................................................................................. 94
4.6 Testes ...................................................................................................................................... 97
4.6.1 Buscar produto pelo nome ....................................................................................................... 97
4.6.2 Buscar produto pelo código de barras ...................................................................................... 99
4.6.3 Produtos mais buscados ......................................................................................................... 101
4.6.4 Ligar para estabelecimento..................................................................................................... 102
4.6.5 Como chegar ao estabelecimento .......................................................................................... 103
4.7 Conclusão .............................................................................................................................. 106
5 CONCLUSÃO ................................................................................................................ 108
5.1 Trabalhos futuros .................................................................................................................. 109
6 REFERÊNCIAS ............................................................................................................. 110
16
1 Introdução
A globalização é caracterizada por um mundo em transformação, composto por
mudanças rápidas e de várias naturezas, com novidades cotidianas, o que exige uma
readequação e adaptação contínua do ser humano, principalmente dentro do mundo
organizacional, exigindo cada vez mais das pessoas (BEDANI, 2011).
É sabido que o tempo é limitado e independente do que aconteça no mundo
globalizado e da rapidez das mudanças, o dia continuará composto por 24 horas. Daí a
importância de revisitar a forma vivida e saber administrar as mudanças e a diversidade
de atividades no dia a dia, o que requer uma melhor gestão do tempo. Surge então a
tecnologia como meio de auxiliar as pessoas, aumentando a sua produtividade na
medida em que libera o seu usuário de tarefas repetitivas, cansativas ou perigosas
(BEDANI, 2011).
O uso de celulares tornou-se algo natural na sociedade atual. O avanço das
tecnologias, no âmbito da mobilidade, tem possibilitado o aumento da capacidade de
armazenamento e processamento dos dispositivos móveis. A praticidade de se
comunicar e efetuar tarefas, antes só possíveis em um PC - Personal Computer - vem
conquistando um número cada vez maior de pessoas. Os usuários podem ouvir músicas,
ver vídeos, ler arquivos e, inclusive, navegar na Internet (ARAÚJO, 2010).
O mercado de dispositivos móveis cresce em grande escala. A consultoria de
mercado da ABI Research (Allied Business Intelligence) diz que 2010 foi um grande
ano para as aplicações móveis e estimou que os downloads nas lojas deste tipo de
software duplicaram neste ano. De acordo com a consultoria, o download de aplicações
móveis cresceu aproximadamente 145 por cento neste ano, alcançando os 5,9 milhões
de dólares, contra os 2,9 mil milhões registrados em 2009. Com base neste crescente
mercado, há um aumento na demanda por aplicações que possam ser executadas em
dispositivos portáteis, com a possibilidade de comunicação com outras aplicações
(NÓBREGA, 2010).
17
A arquitetura para dispositivos móveis necessita de um tratamento diferenciado
das demais tecnologias, pois estes dispositivos têm uma quantidade limitada de
memória e menor poder de processamento. Como a diversidade de dispositivos é quase
ilimitada, a necessidade de ter aplicações portáveis entre os dispositivos, fácil adaptação
à crescente inovação e a segurança, por isso a tecnologia Java foi escolhida (SOUSA,
2010).
1.1 Mercado de celulares
O mundo está se tornando cada vez mais digital. Nas últimas três décadas os
celulares passaram por diversas mudanças, passando de imensos terminais com pouca
inteligência para pequenos computadores pessoais (smartphones), capazes de transmitir
voz e dados. Essa evolução abriu um universo de oportunidades para operadoras,
fabricantes e integradores (ARAÚJO, 2006).
O número de telefones inteligentes no mercado vem crescendo gradativamente
nos últimos anos, devido, principalmente, às novas maneiras de como as pessoas estão
se comunicando, interagindo e trabalhando. Há uma necessidade por provimento de
serviços e acesso às informações de forma eficiente e rápida, especialmente no âmbito
de dispositivos móveis. Existem, atualmente, mais de bilhões de usuários vinculados
a alguma operadora telefônica móvel e a tendência é aumentar ainda mais esses
números. Este aumento do número de aparelhos móveis provoca uma demanda por
novos serviços e aplicativos em variadas plataformas nos quais eles são desenvolvidos e
distribuídos (CARACIOLO, 2009).
Com essa evolução dos celulares, diversos desenvolvedores de software
começaram a escrever aplicativos para plataformas móveis, a fim de lucrar neste novo
mercado emergente. Os desenvolvedores precisam conhecer a fundo este vasto campo
de possibilidades e driblar algumas dificuldades como, por exemplo, o poder de
processamento limitado, telas reduzidas, limitações de memória, dentre outros
fatores que passam a exigir uma maior habilidade dos programadores para a construção
de aplicativos eficientes e usáveis (CARACIOLO, 2009).
18
O mercado tem um número de telefones móveis celulares que ultrapassa o de
terminais fixos. São mais de um bilhão e meio de telefones celulares, sem contar com
outros dispositivos móveis como os PDAs (Personal Digital Assistants). A cada dia que
passa surge aparelhos mais potentes, com novas funcionalidades como capacidade de
capturar imagens e vídeo e reproduzir músicas. Para que esses recursos disponíveis
sejam aproveitados da melhor maneira possível, é preciso que sejam desenvolvidos
aplicativos em linguagens voltadas para dispositivos móveis (ARAÚJO, 2006).
1.2 Identificação do problema
É possível desenvolver um sistema que simplifique todo o processo de compras
do consumidor, desde ao sair de casa até a localização dos produtos nas prateleiras do
estabelecimento comercial?
1.3 Objetivos
1.3.1 Objetivo geral
O objetivo geral deste projeto é facilitar a vida do cliente, evitando a perda de
tempo durante uma tarefa simples e rotineira como fazer compras. Com a utilização do
software desenvolvido, o cliente encontrará o estabelecimento com o uso dos mapas e
também terá maior facilidade em localizar os produtos desejados de uma loja ou
supermercado, sem a necessidade de procurar o produto prateleira por prateleira ou
pedir diversas informações a algum funcionário do estabelecimento.
Já os proprietários do estabelecimento terão um sistema de busca de produtos
eficazes. Conseguirão assim, além de boas avaliações de seus clientes, obterem uma
nova clientela atraída pela praticidade e facilidade em encontrar a mercadoria desejada,
e conseguirão também gerenciar quais os produtos que mais são buscados por eles.
19
1.3.2 Objetivos específicos
Para tanto, os seguintes objetivos específicos foram definidos:
a) Pesquisar e conhecer a fundo a linguagem de programação para
dispositivos móveis Android;
b) Realizar a comunicação entre softwares desktop e softwares mobile,
através do uso de sockets;
c) Integração do Google Maps em uma aplicação para dispositivos móveis;
d) Utilização de recursos de GPS e marcação de locais no mapa.
1.4 Justificativa
Toda pessoa que se encontra na posição de consumidor consegue ver a
dificuldade ao entrar em um estabelecimento e procurar um produto sem ter uma
referência exata de onde o mesmo se encontra. Em alguns supermercados, ainda existem
banners com informações da categoria do produto que se encontram nos corredores,
mas isso não deixa totalmente explícito, pois alguns produtos podem encaixar em mais
de uma categoria.
Outro fator que influenciou no desenvolvimento do projeto, foi o interesse
pessoal na área de programação para desktops e dispositivos móveis.
Por último, o gosto por celulares e as tecnologia que os englobam, a
oportunidade de desenvolver um aplicativo próprio e vê-lo funcionar, foram de forte
influência ao escolher o tema da monografia.
20
1.5 Organização do trabalho
O projeto está organizado em cinco capítulos, a saber:
O capítulo 1 apresenta a introdução referente ao assunto, a identificação do
problema, os objetivos e a justificativa do projeto.
O capítulo 2 apresenta algumas das linguagens de programação para dispositivos
móveis, assim como, as plataformas de desenvolvimento.
O capítulo 3 compreende as ferramentas que foram utilizadas para o
desenvolvimento do projeto.
O capítulo 4 consiste nos diagramas UML (Unified Modeling Language) dos
softwares, seu desenvolvimento e os testes.
O capítulo 5 apresenta as considerações finais e a conclusão do projeto.
21
2 Estado da Arte
Neste capítulo serão abordadas algumas das linguagens de programação e
plataformas de desenvolvimento para celulares mais conhecidas e utilizadas
mundialmente.
2.1 Linguagens para dispositivos móveis
Diversas linguagens de programação podem ser usadas para o desenvolvimento
de aplicativos para os dispositivos móveis. Algumas são baseadas em marcação, onde o
processamento é feito em um servidor remoto até as linguagens tradicionais, e usadas
principalmente por telefones celulares (JOHNSON, 2007). As linguagens tradicionais,
como Lua, C++, Python e Java, permitem o desenvolvimento de aplicações mais
complexas, que podem executar algo no próprio dispositivo, armazenarem dados,
conectarem com servidores remotos, entre diversos recursos existentes, sendo usadas
para desenvolvimento de aplicativos para dispositivos portáteis.
2.1.1 Lua
Lua é uma linguagem de script amplamente usada nas mais diversas áreas, desde
grandes aplicativos para desktops até software para sistemas embarcados. Lua é a
linguagem mais usada atualmente para jogos, e é parte do padrão Ginga para o sistema
brasileiro de televisão digital. É inteiramente projetada, implementada e desenvolvida
no Brasil, por uma equipe na PUC-Rio (Pontifícia Universidade Católica do Rio de
Janeiro) e nasceu no TECGRAF (Grupo de Tecnologia em Computação Gráfica)
(IERUSALIMSCHY, 2009).
Combina sintaxe simples para programação procedural com poderosas
construções para descrição de dados baseadas em tabelas associativa e semântica
extensível. É interpretada a partir de bytecodes para uma máquina virtual baseada em
22
registradores, e tem gerenciamento automático de memória com coleta de lixo
incremental. Lua roda em todas as versões do Unix (Uniplexed Information and
Computing System) e do Windows, e também em dispositivos móveis, como
computadores de mão e celulares que usam BREW (Binary Runtime Environment for
Wireless), Symbian, Pocket PC (Personal Computer) (LUA, 2011).
2.1.2 C/C++
A linguagem C foi criada por Dennis Ritchie em um DEC (Digital Equipment
Corporation) PDP-11 (Programmed Data Processors), usando o sistema operacional
Unix e é o resultado do processo de desenvolvimento iniciado com outra linguagem,
chamada BCPL (Basic Combined Programming Language), desenvolvida por Martin
Richards. A linguagem C tornou-se uma das linguagens de programação mais usadas, e
tem sido utilizada na criação de alguns dos mais importantes produtos de software dos
últimos anos (ROMÃO, 2002).
Quanto ao seu nível, pesquisadores e programadores encontram certa dificuldade
em classificá-la, sendo que alguns autores costumam defini-la como de nível baixo,
como o Assembley e outros como nível médio. Porém é uma linguagem altamente
portável, ou seja, tendo seu código escrito em uma máquina pode facilmente ser
compilado em outra. Hoje em dia, essa vantagem não fica tão evidente, pois existe certa
padronização. Mas até poucos anos atrás havia uma grande diversidade de hardware, o
que causava problemas de incompatibilidade com diversas linguagens. Os arquitetos de
C pensaram nisso, criando uma linguagem que ao invés de comandos, usa funções para
a entrada e saída de dados (ROMÃO, 2002).
Em 1980, Bjarne Stroustrup desenvolveu o C++ como uma ampliação da
linguagem C e foi inicialmente chamado C com classes. Hoje em dia, uma grande
quantidade de empresas de softwares utiliza o C++. O crescimento da linguagem na
área de dispositivos móveis se fortaleceu pela integração com o sistema operacional
Symbian. É uma das melhores linguagens de programação existentes por conseguir
agrupar uma funcionalidade que envolve formulações altamente abstratas como classes,
23
que permitem um trabalho de alto nível e formulações de baixo nível, como o uso de
chamadas de interrupções que realizam tarefas altamente específicas (BUENO, 2002).
2.1.3 Python
Python é uma linguagem de programação de script orientada a objetos,
disponível para diversas plataformas e ambientes. Permite que programas sejam escritos
de forma compacta e legível, possibilitando o rápido aprendizado. Os códigos escritos
em Python são geralmente menores em comparação a códigos equivalentes em C++
ou Java devido ao seu mecanismo de abstração de tipos o qual permite expressar
operações bastante complexas com apenas um comando. É uma linguagem simples, de
código aberto e se aplica a dispositivos móveis (CARACIOLO, 2009).
Possui estruturas de dados de alto-nível eficientes, bem como adota uma
abordagem simples e efetiva para a programação orientada a objetos. Sua sintaxe
elegante e tipagem dinâmica, em adição a sua natureza interpretada, tornam Python
ideal para o desenvolvimento rápido de aplicações em diversas áreas e na maioria das
plataformas disponíveis. O interpretador de Python é facilmente extensível
incorporando novas funções e tipos de dados implementados em C ou C++ e se adequa
como linguagem de extensão para customizar aplicações (ROSSUM, 2004).
2.1.4 Java
Em 1991, na Sun Microsystems, foi iniciado o Green Project, o berço do Java,
uma linguagem de programação orientada a objetos. Os mentores do projeto eram
Patrick Naughton, Mike Sheridan, e James Gosling. O objetivo do projeto não era a
criação de uma nova linguagem de programação, mas antecipar e planejar a "próxima
onda" do mundo digital. Eles acreditavam que em algum tempo haveria uma
convergência dos computadores com os equipamentos e eletrodomésticos comumente
usados pelas pessoas no seu dia a dia (PAULA FILHO, 2008).
24
A Sun anunciou o Java formalmente durante uma conferência, em maio de 1995.
A linguagem chamou a atenção da comunidade de negócios, devido ao enorme interesse
que a web despertava na época. Além disso, também tinha o grande apelo da
portabilidade. Por isso, o Java passou a ser utilizado para desenvolver aplicativos
corporativos de grande porte e aprimorar a funcionalidade de servidores, assim como no
desenvolvimento de aplicativos para dispositivos móveis (CROCE FILHO e RIBEIRO,
2010).
Desde seu lançamento, em maio de 1995, a plataforma Java foi adotada mais
rapidamente do que qualquer outra linguagem de programação na história da
computação. Em 2003 atingiu a marca de quatro milhões de desenvolvedores em todo
mundo. Ela continua crescendo e oferecendo qualidade, desempenho e segurança
(PAULA FILHO, 2008).
O forte crescimento do Java e sua aceitação no mundo da programação fizeram
com que grandes companhias aderissem a esta linguagem. Um dos casos mais recente
foi a criação da plataforma Android, tendo o Java como raiz, pela gigante Google. A
criação do Android veio da necessidade da Google em possuir uma parte do mercado de
dispositivos móveis, e que contivesse suas características, como o desempenho,
inteligência e fácil manutenção.
2.2 Plataformas de desenvolvimento
Uma plataforma de desenvolvimento é um ambiente que possibilita a criação,
confecção ou desenvolvimento de softwares. Elas devem atender as necessidades de
baixo poder de processamento e baixo custo de memória, pois, embora os celulares já
tenham grande nível de avanço em capacidade de memória bem como de
processamento, esses dois quesitos ainda estão longe de alcançar o nível dos desktops.
No mercado atual, existem várias plataformas de desenvolvimento para celulares como
as plataformas Android, Symbian, BREW e Windows Mobile (BUGARIN, BORGES e
DATTOLI, 2009).
25
2.2.1 Android
Android é uma plataforma desenvolvida pela Google voltada para dispositivos
móveis. Em 5 de novembro de 2007, a empresa tornou pública a primeira plataforma
Open Source de desenvolvimento para dispositivos móveis baseada na plataforma Java
com sistema operacional Linux, na qual foi chamada de Android. Essa plataforma é
mantida pela OHA (Open Handset Alliance), um grupo formado por mais de 40
empresas as quais se uniram para inovar e acelerar o desenvolvimento de aplicações,
serviços, trazendo aos consumidores uma experiência mais rica em termos de recursos,
menos dispendiosa em ternos financeiros para o mercado móvel. Pode-se dizer que a
plataforma Android é a primeira plataforma móvel completa, aberta e livre (SILVA,
2010).
O AOSP (Android Open Source Project) está encarregado da manutenção e
desenvolvimento do Android. O objetivo principal é construir uma plataforma de
software excelente para usuários de todos os tipos. Uma série de empresas empenhou
muitos engenheiros para atingir esse objetivo, e o resultado é uma produção total de
produtos de alta qualidade, cuja fonte é aberta para customização e portabilidade
(AMORIM, 2011).
2.2.2 Symbian
Symbian é o sistema operacional mais antigo de smartphones ainda em
desenvolvimento. Iniciou no ano de 1998, em um consórcio entre a Ericsson, Nokia,
Motorola e Psion. Dez anos depois, a Nokia comprou o resto das ações pertencentes a
Sony Ericsson e fundou o Symbian Foundation, com o objetivo de abrir o código do
Symbian (OKADA, 2011).
Com a explosão de consumo dos telefones celulares, a Symbian começou a
desenvolver sistemas para as grandes empresas do ramo, principalmente para a Nokia,
Ericsson e Motorola. Ele é um sistema totalmente modular e permite que cada empresa
crie sua própria interface, portanto este sistema não tem uma cara definida. O software
26
final instalado no dispositivo móvel pode ser um simples sistema de textos em telas
monocromáticas, até um sistema operacional completo e potente (RODRIGUES, 2007).
Este sistema operacional é predominantemente baseado em um ambiente gráfico
bastante simples, onde sua grande preocupação é evitar ao máximo o desperdício de
recursos do celular, como bateria e memória. Para isso ele conta com diversos
mecanismos que são eficientes ao tratar desses problemas (RODRIGUES, 2007).
A plataforma Symbian já foi o sistema operacional mobile mais popular do
mundo, graças ao lançamento de bons celulares equipados com o sistema na época de
ouro da Nokia. Porém a chegada do iPhone e Android e a demora para o Symbian se
adaptar aos novos tempos, onde interfaces otimizadas a toque se tornaram obrigatórias,
tiveram consequência na perda de popularidade do Symbian (OKADA, 2011).
2.2.3 BREW
BREW é um sistema operacional, desenvolvido pela Qualcomm, semelhante ao
Symbian. Possui mensagens, navegação pela Internet e trabalha com a tecnologia de
comunicação CDMA (Code Division Multiple Access). Inclui plataforma de aplicativos
e ferramentas de portagem para fabricantes de dispositivos, como o BREW SDK
(Software Development Kit) e o BDS (BREW Distribution System). Este sistema de
distribuição é controlado e gerenciado pelas operadoras, o que lhes permite obter
aplicativos dos desenvolvedores, comercializá-los e coordenar os processos de
faturamento e pagamento. (BALSEMÃO, 2008).
A plataforma consiste em um conjunto de bibliotecas binárias compiladas,
ligadas para execução nativa e otimizada de forma a permitir que os aplicativos
aproveitem os recursos e serviços de comunicação móvel. Ela controla o fluxo de
eventos de e para os aplicativos, iniciando, interrompendo, suspendendo e retomando a
execução em resposta a eventos apropriados (OLIVEIRA, 2011).
27
Também provê acesso às funções de baixo nível subjacentes do dispositivo de
comunicação móvel através de sua interface de aplicativos. Os desenvolvedores podem
usar o BREW SDK e a linguagem C/C++ e Java para escrever software para o
dispositivo sem precisar ter qualquer conhecimento de sua complexidade. Como a
interface de aplicativos não muda, portar aplicativos de um dispositivo BREW para
outro se torna simples. Essas interfaces são coleções de funções relacionadas a um
serviço específico (OLIVEIRA, 2011).
2.2.4 Windows Mobile
O Windows Mobile é a plataforma para smartphones da Microsoft, que vem se
esforçando para manter o sistema relevante frente aos concorrentes. Diferente do que
temos nos computadores, onde o Windows possui quase 90% do mercado, o Windows
Mobile tem uma participação relativamente pequena nos smartphones, sendo pouco
superior a 15% do total (MORIMOTO, 2010).
Nasceu com a versão 2003 do Visual Studio e hoje em dia existem algumas
versões de Windows Mobile, como o Windows Mobile 5.0 e o 6.0 que utilizam o DOT
NET Compact Framework 2.0. Até o Visual Studio 2005, para se desenvolver uma
aplicação Windows Mobile era necessário utilizar pelo menos a versão profissional que
permitia o desenvolvimento de aplicações Windows Mobile 2003, e para desenvolver
aplicações Mobile 5.0 era necessário fazer o download das ferramentas de
desenvolvimento para a plataforma Windows Mobile 5.0 (OLIVEIRA, 2010).
A ideia era que os aparelhos servissem como opções mais leve e barata que os
notebooks, permitindo editar documentos e executar outras tarefas básicas. O problema
era que eles eram muito lentos e limitados e na época ainda não existiam muitos
softwares para a plataforma, de forma que eles acabaram não emplacando. Alguns
fabricantes, incluindo a HP (Hewlett-Packard), continuaram lançando modelos
aperfeiçoados, incluindo processadores mais rápidos e telas coloridas, mas nenhum se
tornou um grande sucesso de vendas (MORIMOTO, 2010).
28
O Windows Mobile perdeu terreno rapidamente com a chegada do iOS (iPhone
Operating System) e Android. Os principais fatores foram: a lentidão do sistema e a
interface pouco otimizada para telas de toque, com botões pequenos e opções
espalhadas em múltiplos menus. A Microsoft continua fazendo pequenos investimentos
no sistema, trazendo uma interface mais otimizada a telas sensíveis ao toque e
melhoramentos para os dispositivos embarcados que ainda são equipados com o sistema
(OKADA, 2011).
2.3 Conclusão
O crescimento do mercado dos celulares, a rápida evolução no poder de
processamento e a integração de novas funções fizeram com que grandes empresas
investissem no desenvolvimento de novos modelos e também de linguagens que
aderissem e fossem capazes de usar da melhor forma possível os recursos desses
dispositivos. A Google tratou de entrar no jogo do mercado e investiu em sua própria
plataforma de desenvolvimento, aproveitando a popularidade e aceitação que a
linguagem Java tem no mercado mundial, conseguiu forte aprovação e hoje o sistema
Android está presente nos celulares de grandes empresas e tornando-se a plataforma de
desenvolvimento para dispositivos móveis mais usada. No próximo capítulo serão
descritas as ferramentas e as plataformas de desenvolvimento utilizadas para a criação
dos softwares.
29
3 Referencial Teórico
Neste capítulo serão abordadas as ferramentas e as linguagens de programação
utilizadas no desenvolvimento do projeto.
3.1 IDE
IDE, do inglês Integrated Development Environment ou Ambiente Integrado de
Desenvolvimento, é um programa de computador que reúne características e
ferramentas de apoio ao desenvolvimento de software com o objetivo de facilitar este
processo (BASSI, 2011).
Com o uso das IDEs, o desenvolvedor terá, em apenas um software, todos os
itens necessários para o desenvolvimento de um programa, desde o código fonte e a
criação da interface gráfica para usuários, a compilação e criação de arquivos
executáveis além da possibilidade de depuração do código e constante atualização e
melhorias da ferramenta por parte dos desenvolvedores em consequência do código
fonte aberto.
Para o desenvolvimento do projeto foram utilizadas duas das IDEs mais usadas
atualmente para o desenvolvimento na linguagem Java , o NetBeans e o Eclipse.
3.1.1 NetBeans
O NetBeans é um ambiente de desenvolvimento integrado gratuito e de código
aberto para desenvolvedores de software na linguagem Java, C/C++, PHP (Personal
Home Page) , Ruby, entre outras. É executado em várias plataformas, como Windows,
Linux, Solaris e MacOS (Macintosh Operating System) e oferece aos desenvolvedores
ferramentas necessárias para criação de aplicativos profissionais de desktop,
empresariais, web e dispositivos móveis (OFICINA DA NET, 2008).
30
i. Histórico
O projeto do NetBeans foi iniciado em 1996 por dois estudantes tchecos na
Universidade de Charles, em Praga, quando a linguagem de programação Java ainda
não era tão popular como atualmente. Primeiramente o nome do projeto era Xelfi, em
alusão ao Delphi, pois, a pretensão deste projeto era ter funcionalidades semelhantes às
plataformas populares da época que eram mais atrativas por serem ferramentas visuais e
mais fáceis de serem usadas (NETBEANS, 2011).
Em 1999, o projeto já havia evoluído para uma IDE proprietária, com o nome de
NetBeans DeveloperX2, que dava suporte ao Swing, uma API (Application
Programming Interface) que desenha por conta própria todos os componentes, sem
necessidade de delegar essa função ao sistema operacional. Os aprimoramentos no
desempenho vindos com o JDK 1.3 (Java Development Kit), lançado no outono de
1999, tornou o NetBeans uma escolha viável para ferramentas de desenvolvimento
(NETBEANS, 2011).
No verão de 1999, a Sun Microsystems queria ter melhores ferramentas de
desenvolvimento Java e se interessou pelo NetBeans, o qual iria se tornar o conjunto de
ferramentas estrela do próprio criador do Java. No outono, com a próxima geração do
NetBeans Developer em beta, uma negociação foi obtida (NETBEANS, 2011).
Nos dias de hoje, o NetBeans fornece uma base sólida para a criação de projetos
e módulos, possui um grande conjunto de bibliotecas, módulos, protocolos e
ferramentas para a construção de aplicativos de software, além de uma documentação
vasta inclusive em português bem organizada, tais ferramentas auxiliam o
desenvolvedor de forma a escrever seu software de maneira mais rápida. A distribuição
da ferramenta é realizada sob as condições da SPL (Sun Public License), uma variação
da MPL (Mozilla Public License), esta licença tem como objetivo garantir a
redistribuição de conhecimento à comunidade de desenvolvedores quando novas
funcionalidades forem incorporadas à ferramenta (OFICINA DA NET, 2008).
31
Atualmente está distribuído em diversos idiomas e isto o torna cada vez mais
popular, facilitando o acesso a iniciantes em programação e possibilitando o
desenvolvimento de aplicativos multilíngue.
ii. Arquitetura
A arquitetura do NetBeans divide-se em duas seções principais: O core, também
chamado de application runtime, e as APIs abertas, que podem ser encontradas nos
pacotes Java org.netbeans.core.* e org.openide.*, respectivamente. O core implementa
muitas interfaces definidas nas APIs abertas e o runtime engine do NetBeans. As APIs
abertas são o conjunto de ferramentas disponíveis para se escrever plug-ins que
funcionarão dentro do NetBeans. Um plug-in é um arquivo de extensão JAR (Java
Archive) que contém classes Java e um arquivo denominado manifest que descreve para
o NetBeans runtime o que é o plug-in, como instalá-lo e desinstalá-lo (PRADO, 2006).
Tanto para IDEs como para qualquer outra aplicação, essa arquitetura traz
inúmeras vantagens. Como, por exemplo, a habilidade para suportar múltiplas línguas
ou a habilidade para envolver a funcionalidade de outras ferramentas de
desenvolvimento e apresentá-la dentro do IDE. Um simples exemplo deste tipo de
habilidade são os compiladores externos e máquinas virtuais Java. Eles podem ser
usados para compilação e execução definindo-se serviços que lançam um processo
externo e mostram a saída deste processo. Um exemplo mais complexo seria a
integração de uma ferramenta de XML (Extensible Markup Language) pré-existente, ela
poderia ser integrada diretamente através da interface gráfica do NetBeans (PRADO,
2006).
A figura 1 representa detalhadamente os componentes que fazem parte da
arquitetura do NetBeans.
32
Figura 1 - Arquitetura do NetBeans (HUANG, 2010).
• Startup - Fornece o método principal da aplicação, bem como todo o código
necessário para iniciá-lo (NETBEANS, 2011).
• Bootstrap – Permite que o Runtime Container entenda como carregar e compor
em uma única aplicação os módulos (NETBEANS, 2011).
• Filesystem API – Fornece à aplicação um sistema de arquivos virtual
(NETBEANS, 2011).
• Module System API – Fornece o acesso ao ciclo de vida dos módulos do
aplicativo (NETBEANS, 2011).
• Utilities API - Inclui diversas classes de utilitários compartilhados entre os
outros módulos no recipiente de tempo de execução (NETBEANS, 2011).
iii. Utilização
O NetBeans foi utilizado para o desenvolvimento do servidor na linguagem
Java. Um dos motivos para a escolha do NetBeans foi o conhecimento prévio da IDE,
já tendo experiência no ambiente de desenvolvimento e conhecendo bem os recursos
disponíveis.
33
Outro fator significante para escolha do NetBeans foi a integração da API Swing
que fornece componentes gráficos de alto nível, possibilitando uma melhor
compatibilidade entre vários sistemas que tem suporte ao Java. Com a utilização do
Swing é possível que aplicações tenham diferentes tipos de visuais (“Look and Feel”).
3.1.2 Eclipse
Eclipse é uma comunidade de código aberto cujos projetos são concentrados na
criação de uma plataforma de desenvolvimento aberta composta de estruturas,
ferramentas e tempos de execução extensíveis para desenvolvimento, implementação e
gerenciamento de software por todo o ciclo de vida. Eclipse ajuda a cultivar uma
comunidade de software livre e um ecossistema de produtos e serviços complementares
(ANISZCZYK e GALLARDO, 2012).
i. Histórico
O Projeto Eclipse foi originalmente criado pela IBM (International Business
Machines) em novembro de 2001 e suportado por um consórcio de fornecedores de
software. A Eclipse Foundation foi criada em janeiro de 2004 como uma organização
sem fins lucrativos independente para atuar como organizadora da comunidade Eclipse.
Foi criada para permitir o surgimento de uma comunidade ao redor do Eclipse
independente de fornecedor, transparente e aberta. Hoje é composta por pessoas e
organizações de uma seção transversal do segmento de mercado de software
(ANISZCZYK e GALLARDO, 2012).
A Eclipse Foundation gerencia e dirige o desenvolvimento contínuo do Eclipse e
fornece serviços para a comunidade, mas não emprega os desenvolvedores de software
livre que realmente trabalham nos projetos Eclipse. Os desenvolvedores do Eclipse são
normalmente empregados pelas organizações ou são desenvolvedores independentes
que trabalham como voluntários em um projeto de software livre (ANISZCZYK e
GALLARDO, 2012).
34
A IDE Eclipse possui facilidades que vão desde a rápida visualização de todos
os arquivos contidos no projeto, ferramentas de gerenciamento de trabalho coletivo, um
Package Explorer que permite visualizar toda a estrutura de diretórios e arquivos
contidos no projeto e Wizards que são programas que auxiliam na construção rápida de
aplicações com características iniciais já conhecidas (TEIXEIRA, 2008).
ii. Arquitetura
Além da pequena runtime, a plataforma do Eclipse consiste do workbench,
workspace, help, entre outros componentes, representados na figura 2.
Figura 2 - Arquitetura do Eclipse (ECLIPSE, 2007).
A runtime tem como função descobrir quais plug-ins estão disponíveis no
diretório de plug-ins do Eclipse. Cada plug-in tem um arquivo XML que lista as
conexões necessárias. Estas conexões incluem extensões que apontam para outros plug-
ins. Por ter um grande número de plug-ins, muitos não são carregados até que sejam
requeridos de fato, minimizando assim tempo de inicialização e recursos do sistema
(GONÇALVES, 2006).
O workspace é responsável por administrar os recursos do usuário que são
organizados em um ou mais projetos. Cada projeto corresponde a um subdiretório do
35
diretório de workspace do Eclipse. Cada projeto pode conter arquivos e diretórios.
Normalmente cada diretório corresponde a um subdiretório do diretório do projeto, mas
um diretório também pode ser unido a um diretório em qualquer lugar no sistema
(GONÇALVES, 2006).
O workbench é a interface gráfica do usuário do Eclipse. Além de exibir os
familiares menus e caixas de ferramentas, é organizado em perspectivas que contém
visões e editores (GONÇALVES, 2006).
Como a própria plataforma do Eclipse, o componente de ajuda é um sistema de
documentação extensível. Ferramentas podem adicionar documentação em formato
HTML (HyperText Markup Language) e, usando XML é definida uma estrutura de
navegação. Refletindo o modo como plug-ins se conectam com outros plug-ins,
ferramentas de documentação podem inserir tópicos em uma árvore de tópico
preexistente (GONÇALVES, 2006).
iii. Utilização
O Eclipse foi utilizado para o desenvolvimento do software do celular, na
plataforma Android e na linguagem de programação Java, por dois motivos, o primeiro
e mais significativo é que o plug-in oficinal da plataforma Android, o ADT (Android
Development Tools), só foi desenvolvido para o Eclipse. Existem outros, porém não são
tão completos e estáveis quanto o do Eclipse. O plug-in ADT, desenvolvido pela
Google, integra o Eclipse ao Android SDK permitindo a execução, depuração e testes
das aplicações diretamente no Eclipse. O ADT estende os recursos do Eclipse para
permitir a rápida configuração de projetos, criação de aplicações, adição de
componentes e depuração de aplicações (OLIVEIRA, 2010).
A segunda razão de ter escolhido o Eclipse é por ele apresentar uma parte visual
dos arquivos XML. O programador tem a opção de fazer a criação dos layouts da
aplicação tanto pelo código fontes do arquivo XML, digitando o código de cada um dos
componentes, tanto pela parte visual, bastando que o programador arraste os
36
componentes para a tela e posicione-os da maneira desejada, facilitando assim a criação
dos layouts.
3.2 Java
Java é uma linguagem de programação e uma plataforma de computação
lançada pela Sun Microsystems em 1995. É a tecnologia que capacita muitos programas
da mais alta qualidade, como utilitários, jogos e aplicativos corporativos, entre muitos
outros, por exemplo. O Java é executado em mais de 850 milhões de computadores
pessoais e em bilhões de dispositivos em todo o mundo, inclusive telefones celulares e
dispositivos de televisão (ORACLE, 2011).
3.2.1 Plataformas
A tecnologia Java está organizada em três plataformas com objetivos
específicos:
• Java 2 Standard Edition (J2SE ou Java SE): ferramentas e APIs essenciais
para qualquer aplicação Java, inclusive para as outras plataformas. É utilizado para
desenvolver aplicações desktop, com ou sem interface gráfica (BRAZ, 2004).
• Java 2 Enterprise Edition (J2EE ou Java EE): ferramentas e APIs para o
desenvolvimento de aplicações distribuídas. Engloba tecnologias como RMI (Remote
Method Invocation), EJB (Enterprise JavaBeans), JMS (Java Messege Service) (BRAZ,
2004).
• Java 2 Micro Edition (J2ME ou Java ME): ferramentas e APIs para o
desenvolvimento de aplicações para aparelhos portáteis (BRAZ, 2004).
Para o desenvolvimento do servidor foi utilizado a plataforma Java SE.
37
3.2.2 Características
A linguagem Java exibe importantes características que, em conjunto,
diferenciam-na de outras linguagens de programação. Dentre essas características as
mais relevantes são: orientada a objetos, independente de plataforma, desempenho,
segurança e multithreaded (PAULA FILHO, 2008).
• Orientada a Objetos: Java é uma linguagem puramente orientada a objetos,
pois, com exceção de seus tipos primitivos de dados, tudo em Java são classes ou
instâncias de classes. Java atende a todos os requisitos necessários para que uma
linguagem seja considerada orientada a objetos (PAULA FILHO, 2008).
• Independente de Plataforma: Java é uma linguagem independente de
plataforma, ou seja, os programas em Java não são compilados para uma plataforma de
hardware específica, mas sim para uma forma intermediária de código destinada à JVM
(Java Virtual Machine). O formato intermediário é chamado de bytecodes, uma espécie
de linguagem de máquina da JVM que utiliza instruções e tipos primitivos de tamanho
fixo, ordenação big-endian e uma biblioteca de classes padronizada. A máquina virtual
Java é na verdade um interpretador de bytecodes para a plataforma na qual é executada.
Em razão da possibilidade de se implementar uma JVM para qualquer plataforma, é
viável que um mesmo programa Java seja executado em qualquer destas arquiteturas
(PAULA FILHO, 2008).
• Desempenho: Java foi projetada para ser compacta, independente de
plataforma e para utilização em rede, o que levou à decisão de ser interpretada com o
emprego do esquema de bytecodes. Nas primeiras versões, o Java oferecia desempenho
apenas razoável devido ao mecanismo de interpretação. Esta limitação foi superada pela
incorporação de um compilador JIT (Just In Time) na JVM capaz de converter os
bytecodes em código nativo durante a carga do programa, possibilitando uma melhora
significativa no desempenho dos programas Java, equiparando-os ao desempenho
obtido com programas nativos (PAULA FILHO, 2008).
38
• Segurança: Considerando a possibilidade de que aplicações sejam obtidas por
meio de uma rede, a linguagem Java possui mecanismos de segurança que podem, no
caso de applets, evitar, por exemplo, qualquer operação no sistema de arquivos da
máquina-alvo, minimizando problemas de segurança. Tal mecanismo é flexível o
suficiente para determinar se uma applet é considerada segura, especificando nesta
situação diferentes níveis de acesso ao sistema-alvo (PAULA FILHO, 2008).
• Multithreaded: Java oferece recursos para o desenvolvimento de aplicações
capazes de executar múltiplas rotinas concorrentemente, possibilitando inclusive sua
sincronização. Cada uma destas rotinas é como um fluxo de execução independente,
usualmente denominada thread. As threads são um importante recurso de programação
para construção de aplicações mais sofisticadas (PAULA FILHO, 2008).
3.2.3 JVM
A Java Virtual Machine é um programa que carrega e executa os aplicativos
Java, convertendo os bytecodes em código executável de máquina. Ela é responsável
pelo gerenciamento dos aplicativos, à medida que são executados (BAPTISTA,
PALANGANI e DELDOTO, 2009).
Graças à máquina virtual Java, os programas podem funcionar em qualquer
plataforma de hardware e software que possua uma versão da JVM, tornando assim
essas aplicações independentes da plataforma onde funcionam (BAPTISTA,
PALANGANI e DELDOTO, 2009).
A arquitetura da JVM permite um controle muito fino sobre as liberadas para o
código que está rodando na máquina virtual. Isso permite a execução de código
confiável de fontes remotas, um modelo usado pelos applets. Os applets rodam dentro
de uma máquina virtual incorporada ao browser do usuário, executando o código
baixado de um servidor HTTP (HyperText Transfer Protocol) remoto. O código remoto
roda em uma sandbox, que protege o usuário de códigos maliciosos. O autor do applet
pode aplicar um certificado para assinar digitalmente o applet como seguro, dando a ele
39
permissão de sair da sandbox e acessar livremente a máquina onde está rodando
(BAPTISTA, PALANGANI e DELDOTO, 2009).
A figura 3 mostra de forma esquemática o processo de compilação e
interpretação utilizado pelo Java, para conversão dos programas (código-fonte) em
linguagem de máquina.
Figura 3 - Processo de compilação e interpretação utilizado pelo Java (FREITAS, 2010).
3.2.4 Garbage Collection
No C, C++ e em outras linguagens, o programa desenvolvido é responsável pela
alocação e deslocação da memória, o que é um dos principais pontos causadores de
erros. Em Java, quando um objeto é criado, a memória necessária é alocada
automaticamente para ele, pois não há forma de se manipular a memória diretamente.
Podem existir inúmeras variáveis no programa referenciando um mesmo objeto e,
durante o ciclo de execução do programa, o Java verifica se um objeto ainda está sendo
referenciado por alguma variável e, caso não esteja, ele libera automaticamente esta área
que não está sendo utilizada. Ou seja, quando não resta mais nenhuma referência para
um objeto, ele é marcado para ser coletado pelo garbage colletor ou “coletor de lixo”,
que libera a memória ocupada por ele (BRAZ, 2004).
40
O coletor de lixo é executado de tempos em tempos num processo de baixa
prioridade. Quando a JVM não está realizando nenhum processamento, ela executa o
coletor de lixo que vasculha a memória em busca de algum objeto criado e não
referenciado. Quando uma grande quantidade de objetos ou objetos muito grandes não
são mais necessários e não se quer esperar até que o coletor de lixo seja executado para
liberar essa memória, pode-se chamá-lo explicitamente no programa (BRAZ, 2004).
3.2.5 Sockets
Os computadores da Internet são conectados entre si pelo protocolo TCP/IP
(Transmission Control Protocol/ Internet Protocol). Na década de 1980, a ARPA
(Advanced Research Projects Agency) do governo norte-americano forneceu recursos
financeiros à universidade da Califórnia em Berkeley com a finalidade de oferecer uma
implementação UNIX do pacote de protocolos TCP/IP. O que foi desenvolvido então
ficou conhecido como interface de sockets. Hoje, a interface de sockets é o método mais
utilizado para acesso a uma rede TCP/IP (HOPSON e INGRAM, 1997).
Um socket essencialmente é uma conexão de dados transparente entre dois
computadores em uma rede. Ele é identificado pelo endereço de rede dos computadores
e por seus pontos finais e uma porta em cada computador. Os computadores em rede
direcionam os streams de dados recebidos da rede para programas receptores
específicos, associando cada programa a um número diferente, a porta do programa. Da
mesma forma, quando o tráfego de saída é gerado, o programa de origem recebe um
número de porta para a transação. Caso contrário, o computador remoto poderia não
responder à entrada (HOPSON e INGRAM, 1997).
Socket é uma abstração para representar um ponto de conexão em uma rede
TCP/IP. Quando dois computadores querem manter uma conversação, cada um deles
utiliza um socket. Um computador é chamado servidor, ele abre um socket e presta
atenção às conexões. O outro computador denomina-se cliente, ele chama o socket
servidor para iniciar a conexão. Para estabelecer uma conexão, é necessário apenas um
endereço de destino e um número de porta (HOPSON e INGRAM, 1997).
41
Os sockets têm dois modos principais de operação: o modo baseado em
conexões e o modo sem conexão. Os baseados em conexões operam como um telefone,
tendo de estabelecer uma conexão e suspender a ligação. Tudo que flui entre esses dois
eventos chegam na mesma ordem em que foram transmitidos. Os sockets sem conexão
operam como o correio, a entrega não é garantida, e os diferentes itens da
correspondência podem chegar em uma ordem diferente daquela em que foram
enviados (HOPSON e INGRAM, 1997).
O modo a ser utilizado é determinado pelas necessidades de um aplicativo. Se a
conformidade é importante, então a operação baseada em conexões é a melhor opção.
Os servidores de arquivos precisam fazer todos os seus dados chegarem corretamente e
em sequência. Se alguma parte dos dados se perdesse, a utilidade do servidor seria
invalidada. Quando precisar de confiabilidade, a aplicação terá que pagar um preço.
Garantir a sequência e a correção dos dados exigem processamento extra e utilização de
mais memória. Esse overhead adicional pode reduzir o tempo de resposta de um
servidor (HOPSON e INGRAM, 1997).
A operação sem conexão utiliza o UDP (User Datagrama Protocol). Um
datagrama é uma unidade autônoma que tem todas as informações necessárias para
tentar fazer sua entrega. Similar a um envelope, o datagrama tem um endereço do
destinatário e do remetente e contém em seu interior os dados a serem enviados. Um
socket nesse modo de operação não precisa se conectar a um socket de destino, ele
simplesmente envia o datagrama. A operação sem conexão é rápida e eficiente, mas não
é garantida (HOPSON e INGRAM, 1997).
A operação baseada em conexões emprega o TCP. Um socket nesse modo de
operação precisa se conectar ao destino antes de transmitir os dados. Uma vez
conectados, os sockets são acessados pelo uso de uma interface de fluxos: abertura-
leitura-escrita-fechamento. Tudo que é enviado por um socket é recebido pela outra
extremidade da conexão, exatamente na mesma ordem em que foi transmitido. A
operação baseada em conexões é menos eficiente do que a operação sem conexão, mas
é garantida (HOPSON e INGRAM, 1997).
42
Para atender os requisitos do projeto e realizar a comunicação entre os softwares
foram usados os sockets baseados em conexão.
3.2.6 Threads
Thread, ou processo leve, é a unidade básica de utilização da CPU (Central
Processing Unit), consistindo de um contador de programa, um conjunto de
registradores e uma pilha de execução. São estruturas de execução pertencentes a um
processo e assim compartilham os segmentos de código e dados e os recursos alocados
ao sistema operacional pelo processo (SAUVÉ e SANTOS JÚNIOR, 2000).
O conceito de thread foi criado com dois objetivos. O primeiro foi a facilidade
de comunicação entre unidades de execução e redução do esforço para manutenção
dessas unidades. Isso foi conseguido através da criação dessas unidades dentro de
processos, fazendo com que todo o esforço para criação de um processo, manutenção do
espaço de endereçamento lógico, fosse aproveitado por várias unidades processáveis,
conseguindo também facilidade na comunicação entre essas unidades (SAUVÉ e
SANTOS JÚNIOR, 2000).
Uma thread é similar aos programas sequenciais, pois possuem início, sequência
de execução e um fim. Contudo, uma thread não é um programa, ela não pode ser
executada sozinha. Ela deve ser inserida no contexto de uma aplicação, onde essa
aplicação possuirá vários pontos de execuções distintos, cada ponto representado por
uma thread (SAUVÉ e SANTOS JÚNIOR, 2000).
Do momento em que é criada até ser finalizada, a thread passa por diversos
estados e transições. Este conjunto de estados e transições caracteriza o seu ciclo de
vida, o qual pode ser visualizado na figura 4.
43
Figura 4 - Ciclo de vida de uma thread (RAMOS e TEODOROWITSCH, 2009).
As threads são criadas a partir de sua instanciação. Ao chamar o método start(),
ela será colocada na lista de threads prontas a serem executadas pelo sistema
operacional. Quando o sistema operacional seleciona uma thread para ser executada, ela
permanece no estado execução, produzindo as ações do método run() (RAMOS e
TEODOROWITSCH, 2009).
Ela permanece em execução até que seu tempo de uso da CPU se esgote ou com
a chamada do método sleep(), permaneça no estado suspenso durante o tempo
estabelecido e volte ao estado pronto. Em seguida, quando executa o método wait(), ela
permanece no estado suspenso até que outra thread execute o método notify() ou
notifyAll(), voltando ao estado pronto (RAMOS e TEODOROWITSCH, 2009).
Quando necessita de uma operação de entrada e saída, a thread fica no estado
bloqueado até que a operação seja concluída, voltando ao estado pronto. Se a thread
finalizar a execução do seu método run() ou quando for executado o método interrupt(),
ela vai para o estado finalizado (RAMOS e TEODOROWITSCH, 2009).
44
As threads foram usadas para manter a porta de comunicação do servidor aberta
enquanto espera por conexões dos clientes via sockets. Elas foram escolhidas por
permitirem múltiplas conexões simultâneas, o que não é suportado pelos métodos.
3.3 Google Android
O Google Android é uma plataforma de código aberto, para dispositivos móveis,
sendo composta por um sistema operacional, middleware, aplicativos e interface de
usuário. Neste sentido os recursos mais importantes desta plataforma móvel são a
máquina virtual, o navegador, a biblioteca 2D e 3D e o banco de dados SQLite (FARIA,
2008).
Com algumas exceções, a maior parte do Google Android é distribuído sob a
licença Apache 2.0, como descreve Lecheta, (2009):
“A licença do Android é flexível e permite que cada fabricante
possa realizar alterações no código-fonte para customizar seus
produtos, e o melhor de tudo, sem necessidade de compartilhar
essas alterações com ninguém. O Android também é “free”, e os
fabricantes podem usar e abusar dele sem precisar pagar por
isso” (LECHETA, 2009, p.22).
3.3.1 Arquitetura
A arquitetura da plataforma Android é composta por cinco camadas: Linux,
Kernel, Libraries, Android Runtime, Application Framework e Applications. Essa
divisão pode ser observada na Figura 5.
45
Figura 5 - Arquitetura da plataforma Android (PRADO, 2011).
A camada Linux kernel atua como uma camada de abstração entre o hardware e
o software do dispositivo. O Android conta com a versão 2.6 do kernel do Linux
responsável pelos seguintes serviços: segurança, gerenciamento de memória, gestão de
processos, rede e drivers (HASLINGER, 2009).
A camada Libraries é composta por um conjunto de bibliotecas C/C++ utilizadas
por vários componentes do sistema. Sendo que estas funcionalidades são oferecidas aos
desenvolvedores na camada Application Framework (HASLINGER, 2009).
A terceira camada, Android Runtime, é o ambiente de execução da plataforma
Android composto por uma máquina virtual e um conjunto de funcionalidades
fornecidas pelas bibliotecas da linguagem de programação Java. Cada aplicação
Android é uma instância da máquina virtual Dalvik, ou seja, cada aplicação é executada
como um processo distinto dos demais. A Dalvik é uma máquina virtual desenvolvida
especialmente para obter maior desempenho em hardwares com pouco poder de
processamento (HASLINGER, 2009).
Sobre as camadas descritas anteriormente, está localizada a camada Application
Framework. Nessa camada são encontrados todos os recursos e APIs utilizadas pelos
46
aplicativos, como: botões, caixas de texto e outros componentes para composição do
layout das aplicações (HASLINGER, 2009).
A última camada da arquitetura é denominada Applications, na qual se
encontram todos os aplicativos do Android, como navegador web, agenda, jogos entre
outros (HASLINGER, 2009).
3.3.2 Classes Activity e View
As classes Activity e View são responsáveis pela representação gráfica de uma
aplicação Android. A classe android.app.Activity representa uma tela da aplicação,
sendo esta tela composta por elementos visuais, os quais são representados pela classe
android.view.View, como afirma Lecheta, (2009):
“Essas duas classes que sempre andam juntas. A activity define
que existe uma tela, controla seu estado e a passagem de
parâmetros de uma tela para outra, define os métodos que serão
chamados quando o usuário pressionar algum botão. Mas a
activity precisa exibir elementos visuais na tela, e este é o papel
da classe View, que tem a finalidade de desenhar algo na tela
(LECHETA, 2009, p.55).”
No Android, o layout da tela pode ser criado utilizando as classes da API Java
ou podem ser definidos os elementos da tela dentro de um arquivo XML, sendo que este
segundo método deixa o código mais limpo e facilita sua leitura, permitindo a separação
entre a parte visual da aplicação e a lógica da programação, facilitando futuras
manutenções do código.
Para se exibir uma view definida em um arquivo XML, é necessário a utilização
do método setContentView que faz a ligação entre a activity e a view recebida como
parâmetro.
47
3.3.3 Classe R e Arquivo AndroidManifest
A classe R é utilizada para acesso dos recursos do projeto como, por exemplo,
um arquivo XML referente ao layout de uma tela. O arquivo AndroidManifest.xml é o
local onde estão todas as configurações para a execução de uma aplicação. Esta classe é
gerada automaticamente e contém constantes para acessar vários recursos do projeto.
Sempre que um arquivo for adicionado a uma pasta do projeto uma nova constante será
criada na classe R (LECHETA, 2009).
Ao criar um arquivo chamado main.xml na pasta layout do projeto, a classe R irá
criar, automaticamente, uma constante chamada R.layout.main, sendo que, para utilizar
esse recurso chamado main.xml em um projeto, deve-se sempre referenciar a constante
especificada na classe R.
Então, pode-se criar uma activity e utilizar esse layout, bastando que o método
setContentView(R.layout.main) seja chamado, passando como parâmetro a constante
referente ao arquivo XML desejado. Mas para que essa activity criada seja executada
corretamente é necessário configurá-la no arquivo AndroidManifest.xml localizado na
pasta raiz do projeto.
3.3.4 XML
XML é uma linguagem de marcação de dados que provê um formato para
descrever dados estruturados. Isso facilita declarações mais precisas do conteúdo e
resultados mais significativos de busca através de múltiplas plataformas
(ALVARENGA, 2005). Representa uma maneira distinta de fazer as coisas, mais
avançada, cuja principal novidade consiste em permitir compartilhar os dados com os
quais se trabalha a todos os níveis, por todas as aplicações e suportes. Sendo assim, o
XML tem um papel importantíssimo no mundo atual, que tende à globalização e à
compatibilidade entre os sistemas, já que é a tecnologia que permitirá compartilhar a
informação de una maneira segura, confiável e fácil (ALVAREZ, 2004).
48
A plataforma Android dá flexibilidade para usar um ou ambos os métodos para
declarar e gerenciar a interface do usuário do aplicativo. É possível declarar layouts
padrão do aplicativo em XML, incluindo os elementos da tela que aparecerão nela e
suas propriedades (AMORIM, 2011).
A vantagem de declarar a interface em XML é que ela permite melhor separar a
apresentação da aplicação do código que controla o seu comportamento. As descrições
de interface do usuário são externas a aplicação, o que significa que é possível
modificá-la ou adaptá-la sem ter que modificar o código. Além disso, declarar o layout
em XML torna mais fácil visualizar a estrutura da interface do usuário, por isso é mais
fácil depurar problemas (AMORIM, 2011).
3.3.5 Barcode Scanner
Barcode Scanner é um aplicativo, desenvolvido na plataforma Android, que
aliado à câmera digital do aparelho, lê as informações do QR Code (Quick Response
Code) e de códigos de barras normais. Faz a leitura utilizando a câmera traseira do
aparelho celular e possui um recurso de pesquisa do produto, pelo seu código de barras,
em sites, a fim de comparar os preços da mercadoria e encontrar em qual loja o preço
está mais acessível.
O aplicativo foi desenvolvido pela companhia ZXing Team, sua licença é
gratuita e está disponível para download no site da Google Play (site oficial da Google
para download de aplicativos desenvolvidos na plataforma Android):
https://play.google.com/store/apps/details?id=com.google.zxing.client.android&feature.
O Barcode Scanner foi utilizado para ler o código de barra dos produtos e
devolver para o software do cliente o código de barras lido. Esta funcionalidade foi
adicionada para facilitar a consulta ao preço do produto depois de localizado pelo
cliente. A figura 6 ilustra a utilização do Barcode Scanner para a leitura de um código
de barras.
49
Figura 6 – Aplicativo Barcode Scanner (BESTANDROID, 2009).
3.4 Google Maps
Google Maps é o serviço que a Google oferece de pesquisa e visualização de
mapas e imagens de satélite gratuito na web. A ferramenta é uma das mais usadas
devido as suas funcionalidades como: carregamento rápido, zoom e navegação
simplificada (MELO, 2009). A figura 7 mostra o mapa do Brasil visto no Google Maps.
Figura 7 - Mapa do Brasil no Google Maps (GOOGLE, 2012).
O Google Maps possui recursos interessantes, tanto para programadores como
para usuários comuns, como: marcadores para demarcação de locais no mapa, balões de
informação, usado para exibir dados sobre o local apontado e a possibilidade de
incorporá-lo em uma aplicação mobile. Também é possível utilizar o recurso de GPS
50
(Global Positioning System) do celular para mostrar no mapa a posição real do
dispositivo e caso ocorra mudança de posição do aparelho, as posições são atualizadas
no mapa.
Ele disponibiliza três formas de visualização: mapa, satélite e terreno. No modo
mapa é exibido um mapa político do local, sendo que as ruas mais importantes são
mostradas na cor amarela e as demais na cor branca. No modo satélite são mostradas
fotos tiradas por satélites, ou seja, uma vista panorâmica do local. Já o modo terreno é
uma junção entre os dois modos anteriores, permitindo uma melhor visualização de
bairros, terrenos e cidades. A figura 8 mostra a cidade de Ituiutaba vista no modo mapa,
a figura 9 no modo satélite e a figura 10 no modo terreno.
Figura 8 - Cidade de Ituiutaba vista no modo mapa (GOOGLE, 2012).
Figura 9 - Cidade de Ituiutaba vista no modo satélite (GOOGLE, 2012).
51
Figura 10 - Cidade de Ituiutaba vista no modo terreno (GOOGLE, 2012).
Para o desenvolvimento do projeto serão utilizadas as visualizações no modo
mapa e no modo satélite, os recursos de marcação de pontos no mapa e a localização do
dispositivo móvel através do GPS interno do celular.
3.5 Banco de Dados
O armazenamento de dados é um dos pontos principais que deve ser considerado
no desenvolvimento de uma aplicação. Sem ele, os dados ficam disponíveis apenas em
tempo de execução, ou seja, após a execução do programa, esses dados são perdidos.
Com isso, faz-se necessário algum mecanismo para persistência dos dados.
Para que os dados sejam mantidos ao fechar uma aplicação é necessário o uso de
um banco de dados, que é um conjunto de registros dispostos em estrutura regular que
possibilita a reorganização dos mesmos e produção de informação. Um banco de dados
é usualmente mantido e acessado por meio de um software conhecido como SGBD
(Sistema Gerenciador de Banco de Dados) que normalmente adota um modelo de
dados, de forma pura, reduzida ou estendida. O modelo de dados mais adotado hoje em
dia é o modelo relacional, onde as estruturas têm a forma de tabelas, compostas por
tuplas e colunas (ORACLE, 2006).
52
A linguagem de pesquisa utilizada em banco de dados relacional é o SQL
(Structured Query Language) que foi desenvolvida para ser uma linguagem padrão para
operações com banco de dados. A linguagem SQL foi elaborada para ser independente
de hardware ou de software, ou seja, não há necessidade de saber a respeito do software
de banco de dados ou do hardware envolvido em uma operação. Basta conhecer os
comandos SQL padrão para solicitar informações, que obrigatoriamente é o mesmo em
todos os sistemas que o utilizam (OLIVEIRA e PHILERENO, 2005).
3.5.1 SQLite
No contexto de aplicações para dispositivos móveis, a escassez de recursos
computacionais, tais como memória, capacidade de armazenamento, combinado com a
falta de suporte, faz com que os desenvolvedores para estes tipos de dispositivos não
desfrutem dos benefícios de um SGBD. Muitas tecnologias para desenvolvimento
móvel, assim como no início do desenvolvimento de aplicações desktop, se baseiam em
arquivos para armazenar dados (DEVMEDIA, 2011).
A plataforma Java ME possui o RMS (Record Management System) que
consiste em uma API que dispõe de métodos para manipular registros. Entretanto, a
manipulação de dados nessa API não poupa o desenvolvedor de lidar com rotinas de
baixo nível para serialização dos dados, já que a API só trabalha com bytes
(DEVMEDIA, 2011).
Em contrapartida, a plataforma Android, dentre uma série de inovações e
facilidades, trouxe suporte nativo ao SQLite que é uma pequena biblioteca,
desenvolvida em linguagem C, onde implementa-se um amplo subconjunto do standard
SQL 92, sendo a sua reputação proveniente da combinação do motor de base de dados
com a interface dentro de uma única biblioteca (BALTAZAR, 2012).
O desenvolvedor pode criar o banco de dados e as tabelas, assim como
manipular seus dados através dos comandos DDL (Data Definition Language) e DML
(Data Manipulation Language) do SQL padrão. Isso traz um ganho considerável de
53
produtividade, pois o desenvolvedor agora pode apenas focar nas regras de negócio,
tendo em vista que os serviços para persistência de dados são fornecidos pelo SQLite
(DEVMEDIA, 2011).
O SQLite foi utilizado para o armazenamento do histórico de consultas feitos no
software do cliente.
3.6 Conclusão
Neste capítulo foram descritas as tecnologias que serão utilizadas no estudo de
caso desenvolvido no próximo capítulo.
Para o desenvolvimento dos softwares dos dispositivos móveis foi utilizado o
Eclipse por possuir o plug-in oficial do Android, desenvolvido pela Google e por ter
uma parte visual para a criação dos layouts. Já para o software do servidor foi utilizado
o NetBeans por ter a API Swing, facilitando a criação das interfaces do software e pelo
conhecimento prévio desta IDE pelo autor do projeto.
Ambos os softwares foram desenvolvidos na linguagem Java, sendo que o
servidor foi feito na plataforma Java SE e o software do cliente na plataforma Android.
Para a comunicação entre os softwares foram utilizados os sockets baseados em conexão
e as threads para mantê-los abertos. Para o armazenamento do dados no software do
cliente foi utilizado o SQLite que é o banco de dados padrão do Android.
Em momento algum é pretendido por este projeto realizar operações de
transações de estoque em softwares de gerenciadores dos mesmos. As tabelas utilizadas
até podem ser oriundas destes softwares, desde que acrescidas das informações de
localização dos produtos. Esta localização pode ser inserida pelo software servidor
desenvolvido neste trabalho.
54
O aplicativo Barcode Scanner foi adicionado para facilitar a consulta ao preço
do produto depois de localizado pelo cliente. Ele foi utilizado para ler o código de barra
dos produtos e devolver para o software do cliente o código de barras lido.
Uma das funcionalidades de localização diz respeito a como o cliente chega até
o comércio. Para tanto, a posição do mesmo é marcada no mapa, e a posição do cliente
atualizada em tempo real. Foi utilizado o Google Maps para prover esta funcionalidade.
55
4 Estudo de Casos
O objetivo do sistema desenvolvido como estudo de caso nesta monografia é
facilitar ao máximo o processo de compra realizado pelo cliente, desde antes de chegar
ao comércio até o momento de encontrar a posição dos produtos nas prateleiras. Neste
capítulo serão demonstrados os diagramas de funcionamento do projeto (diagrama de
caso de uso, diagrama de sequência e diagrama de classe), seguido do desenvolvimento
do mesmo e os testes dos softwares.
4.1 Diagrama de caso de uso
O diagrama de caso de uso do servidor possui dois atores, o administrador do
sistema, que possui todos os privilégios do software, e o usuário do sistema, que possui
algumas restrições no uso do software.
O usuário do sistema tem as funcionalidades de cadastrar, editar, visualizar e
excluir os produtos, podendo também visualizar os produtos mais buscados pelos
clientes e abrir os sockets de conexão para que os clientes possam realizar a busca pelos
produtos.
Já o administrador do sistema, além das funcionalidades do usuário, tem as
funções de visualizar, cadastrar, alterar e excluir os usuários do sistema. Outra função
específica do administrador é a opção de verificar o relatório dos usuários, tendo acesso
ao relatório de utilização do sistema.
A figura 11 representa o diagrama de caso de uso do servidor.
56
Figura 11 - Diagrama de caso de uso do servidor.
Após a ilustração do caso de uso do servidor, segue a documentação,
representada nas tabelas de 1 a 12.
57
Caso de uso Efetuar log-in.
Ator principal Usuário.
Pré-condição Usuário estar cadastrado.
Fluxo normal 1. Informar usuário.
2. Informar senha. 3. Fazer log-in.
Fluxos excepcionais 1. Usuário ou senha inválido.
1. a. Informar usuário e senha novamente.
1. b. Fazer log-in.
Fluxos alternativos
Pós-condição Acesso permitido ao sistema.
Tabela 1 - Caso de uso do cliente: efetuar log-in.
Caso de uso Cadastrar produto.
Ator principal Usuário.
Pré-condição Ter feito log-in.
Fluxo normal 1. Preencher dados do produto.
2. Cadastrar produto.
Fluxos excepcionais 2. Produto já cadastrado.
2. a. Informar novo produto
2. b. Cadastrar produto.
Fluxos alternativos
Pós-condição Produto cadastrado com sucesso.
Tabela 2 - Caso de uso do cliente: cadastrar produto.
58
Caso de uso Editar produto.
Ator principal Usuário.
Pré-condição Ter feito log-in.
Fluxo normal 1. Escolher produto a ser editado.
2. Modificar os dados do produto.
3. Alterar produto.
Fluxos excepcionais 3. Produto já cadastrado.
3. a. Informar novo produto
3. b. Alterar produto.
Fluxos alternativos
Pós-condição Produto alterado com sucesso.
Tabela 3 - Caso de uso do cliente: editar produto.
Caso de uso Visualizar produto.
Ator principal Usuário.
Pré-condição Ter feito log-in.
Fluxo normal 1. Inserir nome do produto a ser buscado.
2. Visualizar informações do produto.
Fluxos excepcionais 1. Produto não encontrado.
1. a. Inserir novamente o nome do produto.
Fluxos alternativos
Pós-condição Visualização das informações do produto.
Tabela 4 - Caso de uso do cliente: visualizar produto.
59
Caso de uso Excluir produto.
Ator principal Usuário.
Pré-condição Ter feito log-in.
Fluxo normal 1. Selecionar produto a ser excluído.
2. Excluir produto.
Fluxos excepcionais
Fluxos alternativos
Pós-condição Produto excluído com sucesso.
Tabela 5 - Caso de uso do cliente: excluir produto.
Caso de uso Visualizar produtos mais buscados.
Ator principal Usuário.
Pré-condição Ter feito log-in.
Fluxo normal 1. Visualizar a tabela com os produtos mais buscados.
Fluxos excepcionais
Fluxos alternativos
Pós-condição Visualização dos produtos mais buscados.
Tabela 6 - Caso de uso do cliente: Visualizar produtos mais buscados.
60
Caso de uso Abrir/Fechar conexão.
Ator principal Usuário.
Pré-condição Ter feito log-in.
Fluxo normal 1. Abrir porta de conexão para os clientes.
1.a. Permitir conexão dos clientes.
2. Fechar porta de conexão para os clientes.
2. a. Bloquear conexão dos clientes.
Fluxos excepcionais
Fluxos alternativos
Pós-condição Porta de conexão aberta ou fechada.
Tabela 7 - Caso de uso do cliente: Abrir/Fechar conexão.
Caso de uso Cadastrar usuário.
Ator principal Administrador.
Pré-condição Ter feito log-in.
Fluxo normal 1. Preencher dados do usuário.
2. Cadastrar usuário.
Fluxos excepcionais 2. Usuário já cadastrado.
2. a. Informar novo usuário
2. b. Cadastrar usuário.
Fluxos alternativos
Pós-condição Usuário cadastrado com sucesso.
Tabela 8 - Caso de uso do administrador: cadastrar usuário.
61
Caso de uso Editar usuário.
Ator principal Administrador.
Pré-condição Ter feito log-in.
Fluxo normal 1. Escolher usuário a ser editado.
2. Modificar os dados do usuário.
3. Alterar usuário.
Fluxos excepcionais 3. Usuário já cadastrado.
3. a. Informar novo usuário
3. b. Alterar usuário.
Fluxos alternativos
Pós-condição Usuário alterado com sucesso.
Tabela 9 - Caso de uso do administrador: editar usuário.
Caso de uso Visualizar usuário.
Ator principal Administrador.
Pré-condição Ter feito log-in.
Fluxo normal 1. Inserir nome do usuário a ser buscado.
2. Visualizar informações do usuário.
Fluxos excepcionais 1. Usuário não encontrado.
1. a. Inserir novamente o nome do usuário.
Fluxos alternativos
Pós-condição Visualização das informações do usuário.
Tabela 10 - Caso de uso do administrador: visualizar usuário.
62
Caso de uso Excluir usuário.
Ator principal Administrador.
Pré-condição Ter feito log-in.
Fluxo normal 1. Selecionar usuário a ser excluído.
2. Excluir usuário.
Fluxos excepcionais
Fluxos alternativos
Pós-condição Usuário excluído com sucesso.
Tabela 11 - Caso de uso do administrador: excluir usuário.
Caso de uso Gerar relatório de usuários.
Ator principal Administrador.
Pré-condição Ter feito log-in.
Fluxo normal 1. Visualizar o relatório de usuários.
1. a. Buscar por usuário específico.
1. b. Buscar relatório por data.
Fluxos excepcionais 1. Usuário não encontrado.
1. a. Inserir novo usuário.
2. Data não encontrada.
2. b. Inserir nova data.
Fluxos alternativos
Pós-condição Visualização do relatório.
Tabela 12 - Caso de uso do administrador: verificar relatório de usuários.
63
O diagrama de caso de uso do cliente tem como único ator o cliente. O cliente
tem as opções de buscar o produto pelo nome, pelo código de barras e também
visualizar os produtos que mais são buscados pelos clientes. Todas essas informações
são armazenadas no banco de dados do servidor (não é intenção do autor do projeto
gerenciar o banco de dados) e a troca de dados entre o software do cliente e o servidor é
feita pelo uso dos sockets.
O cliente também tem as opções de ligar para o estabelecimento e visualizar os
mapas, onde verá sua localização e a do estabelecimento. Para que o cliente veja sua
posição em tempo real no mapa, o celular manda as informações de sua localização para
um servidor de GPS (o funcionamento do servidor do GPS não é de responsabilidade do
autor do projeto), assim como a latitude e a longitude para criar um marcador em cima
da posição do estabelecimento no mapa.
A figura 12 representa o diagrama de caso de uso do cliente, seguido pela sua
documentação, representada nas tabelas de 13 a 19.
64
Figura 12 - Diagrama de caso de uso do cliente.
65
Caso de uso Buscar produto pelo nome.
Ator principal Cliente.
Pré-condição Estar conectado a rede sem fio do estabelecimento.
Fluxo normal 1. Inserir nome do produto a ser buscado.
2. Enviar o nome inserido para o servidor.
3. Receber os produtos encontrados.
4. Escolher o produto dentre os encontrados.
5. Visualizar as informações do produto.
Fluxos excepcionais 3. Produto não encontrado.
3. a. Inserir nome do produto novamente.
Fluxos alternativos
Pós-condição Visualização das informações do produto.
Tabela 13 - Caso de uso do cliente: buscar produto pelo nome.
Caso de uso Buscar produto pelo código de barras.
Ator principal Cliente.
Pré-condição Estar conectado a rede sem fio do estabelecimento.
Ter o aplicativo Barcode Scanner instalado no celular.
Fluxo normal 1. Iniciar o Barcode Scanner.
2. Ler o código de barras do produto.
3. Enviar o código de barras para o servidor.
4. Visualizar informações do produto.
Fluxos excepcionais 4. Código de barras não encontrado
4. a. Fazer a leitura de outro código de barras
Fluxos alternativos
Pós-condição Visualização das informações do produto.
Tabela 14 - Caso de uso do cliente: buscar produto pelo código de barras.
66
Caso de uso Visualizar produtos mais buscados.
Ator principal Cliente.
Pré-condição Estar conectado a rede sem fio do estabelecimento.
Fluxo normal 1. Receber lista dos 5 produtos mais buscados.
2. Escolher o produto que deseja visualizar.
3. Visualizar informações do produto.
Fluxos excepcionais
Fluxos alternativos
Pós-condição Visualização das informações do produto.
Tabela 15 - Caso de uso do cliente: visualizar produtos mais buscados.
Caso de uso Ligar para estabelecimento.
Ator principal Cliente.
Pré-condição Ter crédito para realizar ligações no celular.
Fluxo normal 1. Realizar a chamada.
2. Encerrar a chamada.
Fluxos excepcionais 1. Telefone ocupado.
1. a. Realizar a chamada novamente.
Fluxos alternativos
Pós-condição Conversar com o atendente do estabelecimento.
Tabela 16 - Caso de uso do cliente: ligar para o estabelecimento.
67
Caso de uso Visualizar mapa.
Ator principal Cliente.
Pré-condição Estar conectado a Internet ou ter plano de dados no celular.
Fluxo normal 1. Carregar os mapas no celular
2. Visualizar os mapas.
Fluxos excepcionais
Fluxos alternativos 1. Mudar exibição do mapa.
1. a. Visualizar mapa modo “mapa”.
2. a. Visualizar mapa no modo “satélite”.
Pós-condição Visualização dos mapas.
Tabela 17 - Caso de uso do cliente: visualizar mapa.
Caso de uso Visualizar posição comércio.
Ator principal Cliente.
Pré-condição Estar conectado a Internet ou ter plano de dados no celular.
Fluxo normal 1. Carregar os mapas no celular.
2. Visualizar a posição do comércio marcada no mapa.
Fluxos excepcionais
Fluxos alternativos
Pós-condição Visualização da posição do estabelecimento.
Tabela 18 - Caso de uso do cliente: visualizar posição comércio.
68
Caso de uso Visualizar própria posição.
Ator principal Cliente.
Pré-condição Estar conectado a Internet ou ter plano de dados no celular.
Estar com o GPS do celular ativo.
Fluxo normal 1. Carregar mapas no celular.
2. Visualizar a posição do cliente no mapa.
3. Atualizar a mudança de posição do cliente.
Fluxos excepcionais
Fluxos alternativos
Pós-condição Visualização própria posição do cliente.
Tabela 19 - Caso de uso do cliente: visualizar própria posição.
4.2 Diagrama de sequência
Nesta seção serão mostrados os diagramas de sequência dos softwares.
As figuras de 13 a 19 apresentam os diagramas de sequência do usuário.
Inicialmente o usuário precisa fazer log-in no servidor para utilizá-lo. Após ter feito log-
in, ele pode realizar as ações de cadastrar, editar, visualizar, excluir os produtos e
visualizar quais são os produtos mais buscados pelos clientes. Para essas ações são
realizadas consultas ao banco de dados do estabelecimento (não gerenciado pelo autor
do projeto). O usuário também tem a opção de abrir e fechar a porta de conexão para
acesso dos clientes. As ações do usuário são gerenciadas pelo controle de dados do
sistema e retornam para ele, na interface, o resultado da operação realizada.
69
Figura 13 – Diagrama de sequência do usuário – Efetuar log-in.
Figura 14 – Diagrama de sequência do usuário – Cadastrar produto.
Figura 15 - Diagrama de sequência do usuário - Visualizar produto.
70
Figura 16 – Diagrama de sequência do usuário - Editar produto.
Figura 17 - Diagrama de sequência do usuário - Excluir produto.
71
Figura 18 - Diagrama de sequência do usuário - Produtos mais buscados.
Figura 19 - Diagrama de sequência do usuário - Abrir/Fechar conexão.
As figuras de 20 a 24 apresentam o diagrama de sequência do administrador do
sistema. Além de todas as funções realizadas pelo usuário, que foram mostradas nos
diagramas anteriores, o administrador tem as opções de visualizar cadastrar, editar e
excluir os usuários que utilizam o sistema e também gerar o relatório dos horários em
72
que estes usuários fizeram log-in e log-out. As ações realizadas pelo administrador
passam pelo controle de dados do sistema, o qual busca as informações desejadas no
banco de dados e retorna para o administrador, na interface, o resultado de sua
operação.
Figura 20 - Diagrama de sequência do administrador – Cadastrar usuário.
Figura 21 - Diagrama de sequência do administrador - Editar usuário.
73
Figura 22 - Diagrama de sequência do administrador - Visualizar usuário.
Figura 23 - Diagrama de sequência do administrador - Excluir usuário.
Figura 24 - Diagrama de sequência do administrador - Gerar relatório usuário.
74
As figuras de 25 a 31 apresentam o diagrama de sequência do cliente. As ações
de busca do produto pelo nome e visualizar os produtos mais buscados, envia as
informações para o servidor que trata os dados e devolve os registros encontrados para o
cliente. Já a opção de busca do produto pelo código de barras, inicia o aplicativo
Barcode Scanner, o qual lê o código de barras do produto e envia para o servidor. O
servidor analisa o código de barras recebido, e se algum produto for encontrado,
devolve as informações referentes ao produto.
O cliente, além das opções de busca de produtos, pode também ligar para o
estabelecimento e pode utilizar recursos de mapa e GPS para saber a posição do
estabelecimento e a sua posição atual. Ao ligar para o estabelecimento, o controle de
dados do software envia uma solicitação à operadora telefônica que realiza a ligação. A
ligação fica ativa até que seja encerrada pelo cliente.
Já a opção de visualização de mapas quando solicitada pelo cliente, requisita os
mapas do Google Maps e os carrega na interface do software do cliente, realizando a
marcação da posição do comércio que já é pré-estabelecida. Se o cliente estiver com o
GPS do celular ativo, a interface do software solicita o recurso de GPS para realizar a
marcação da posição atual do cliente, que é atualizada a cada mudança de posição.
Figura 25 - Diagrama de sequência do cliente - Buscar produto pelo nome.
75
Figura 26 - Diagrama de sequência do cliente - Buscar produto pelo código de barras.
Figura 27 - Diagrama de sequência do cliente - Visualizar produtos mais buscados.
76
Figura 28 - Diagrama de sequência do cliente - Ligar para estabelecimento.
Figura 29 - Diagrama de sequência do cliente – Visualizar mapa.
Figura 30 - Diagrama de sequência do cliente - Visualizar posição comércio.
77
Figura 31 - Diagrama de sequência do cliente - Visualizar própria posição.
4.3 Diagrama de classe
O diagrama de classe do projeto é composto pelo diagrama de classe do servidor
e do cliente.
O diagrama de classe do servidor possui as classes “Produto”, que possui as
informações dos produtos (nome, preço, localização e tipo), e “Usuario”, que possui os
campos usuário e senha. Estas classes fazem uso da classe “Util”, que possui algumas
formatações e validações de campos, e da classe “conexaoBD”, responsável pela
conexão ao banco de dados. As classes “Thread” e “Socket” são utilizadas para realizar
a comunicação entre o software servidor e o cliente. A figura 32 representa o diagrama
de classe do servidor.
78
Figura 32 - Diagrama de classe do servidor.
O diagrama de classe do software do cliente possui a interface “Principal” que é
responsável por iniciar as interfaces: “Histórico” (histórico das buscas realizadas),
“Consulta” (interface para inserir o nome do produto que será buscado) e “Mapa”
(interface onde os mapas serão carregados), além de importar recursos da classe
“net.URI” do Android, responsável por tratar as ligações telefônicas. A interface
“Consulta” é responsável por iniciar a interface “ResultadoConsulta” (utilizada para
apresentar os produtos encontrados na busca), que por sua vez inicia a interface
“CaracteristicaProduto” (para o produto selecionado anteriormente, mostra as
características específicas).
79
A interface “Mapa” importa os recursos da classe “android.Maps” do Android,
responsável pelo carregamento dos mapas, e utiliza os recursos da classe
“MapaLocalOverlay”, que realiza a marcação de pontos no mapa. A figura 33
representa o diagrama de classe do cliente.
Figura 33 - Diagrama de classe do cliente.
80
4.4 Desenvolvimento do software servidor
O servidor descrito nos diagramas foi desenvolvido na linguagem de
programação Java. Ao iniciar o desenvolvimento do servidor, a preocupação inicial foi
em relação à comunicação entre os softwares e como manter essa comunicação aberta
esperando por conexões. Outro fator relevante é quanto à segurança, sendo que o
sistema possui um único usuário administrador, que possui privilégios administrativos,
e os usuários comuns, operadores do sistema, que possuem algumas restrições.
4.4.1 Acesso ao sistema
Ao abrir o software, é preciso inserir um nome de usuário e senha para acessá-lo,
como é mostrado na figura 34.
.
Figura 34 - Tela de acesso ao sistema.
Ao efetuar log-in como administrador, é possível utilizar todas as funções do
sistema como, por exemplo, gerenciar os usuários do sistema e gerar relatórios de log-in
81
e log-out dos usuários, como pode ser visto na figura 35, tela de administrador do
sistema.
Figura 35 - Acesso ao sistema como administrador.
Já ao usuário comum, essas opções não estão disponíveis. As opções de
“Usuários” e “Relatório” ficam ocultas, podendo utilizar apenas as outras funções que
não necessitam de privilégios administrativos, como mostrado na figura 36.
82
Figura 36 - Acesso ao sistema como usuário comum.
4.4.2 Utilização das threads
As threads foram utilizadas para manter a porta de comunicação aberta. Para sua
utilização, inicialmente são declarados seus objetos, sendo que a thread é uma classe
específica dentro da classe onde ela será usada. É declarado um objeto da classe Thread,
o “objConectarCliente”, e também a criação da própria thread, “threadCliente”, vistas
no código abaixo:
private ConexaoCliente objConectarCliente = new ConexaoCliente();
private Thread threadCliente = new Thread(objConectarCliente);
Após isso, é declarada a classe da thread, “ConexaoCliente”, onde encontra-se o
método run(), que inicializa a execução do conteúdo interno da thread. Dentro deste
método deve ser inserido todo o código que será executado. Ao final, coloca-se uma
83
recursividade no método, threadCliente.run(), para que ele seja executado novamente e
entre em loop.
public class ConexaoCliente extends Thread {
public void run() {
// Todo conteúdo a ser executado pela thread deve ser inserido aqui.
threadCliente.run();
}
}
Para ativar e desativar a thread foram inseridos dois botões na interface do
software, o botão “Permitir Conexão” e o “Bloquear Conexão”. A conexão inicia-se
como inativa (mostrada na figura 37).
Figura 37 - Permitir conexões dos clientes.
84
Ao pressionar o botão “Permitir Conexão” (figura 38), a thread é iniciada
mantendo assim a porta dos sockets aberta até que o botão “Bloquear Conexão” seja
pressionado e a interrompa.
Figura 38 - Bloquear conexões dos clientes.
Para gerenciar o funcionamento da thread, foi criado um contador do tipo inteiro
iniciado com o valor zero. Na primeira vez em que a thread for ativada, o contador
estará com o valor zero, fazendo com que ela seja iniciada, threadCliente.start(), o texto
do label passe de “Inativa” para “Ativa” e incremente o contador em um, como mostra o
código abaixo:
if (contadorThread == 0) {
threadCliente.start();
jLabelConexao.setText("Ativa");
contadorThread++;
}
85
Já na segunda vez em que for ativada, o contador não estará mais em zero,
fazendo com que a thread que estava parada retome sua execução,
threadCliente.resume(), em vez de ser iniciada novamente, conforme o código:
else{
threadCliente.resume();
jLabelConexao.setText("Ativa");
}
Para o botão “Bloquear Conexão”, utiliza-se o método suspend() para suspender
a execução da thread, até que o método resume() ative-a novamente, e o texto do label
volte para “Inativa”.
4.4.3 Transmissão dos dados via sockets
Para a transmissão de dados entre o software do cliente e o servidor foram
utilizados os sockets. Inicialmente são declaradas as variáveis necessárias para seu
funcionamento, sendo elas das classes Socket e ServerSocket, como é mostrado abaixo:
private ServerSocket serverSocketEntrada, serverSocketSaida;
private Socket socketEntrada, socketSaida;
Após a declaração das variáveis, todo o conteúdo restante do socket é inserido
dentro da thread mostrada anteriormente e circundado com as instruções try e catch. Ao
iniciar a execução da thread, a variável “serverSocketEntrada” é instanciada e define-se
a porta de comunicação por onde o socket receberá a entrada de dados. No projeto, foi
utilizada a porta 1234. Após isso, o socket fica aberto e espera até que haja a conexão de
algum cliente. Quando ocorrer a conexão, o objeto “dadosEntradaCliente”, que é
responsável por receber os dados, é instanciado e recebe os dados enviados pelo cliente.
O código abaixo mostra o recebimento de dados pelo servidor:
86
try {
serverSocketEntrada = new ServerSocket(1234);
socketEntrada = serverSocketEntrada.accept();
DataInputStream dadosEntradaCliente = new
DataInputStream(socketEntrada.getInputStream());
} catch (IOException erro) {
JOptionPane.showMessageDialog(null, "Erro : " + erro);
}
Ao final do recebimento de dados pelo servidor, os sockets e o canal de
recebimento de dados são fechados.
try {
socketEntrada.close();
serverSocketEntrada.close();
dadosEntradaCliente.close();
} catch (IOException erro) {
JOptionPane.showMessageDialog(null, "Erro : " + erro);
}
Após o fechamento do socket de entrada e do canal de recebimento de dados, são
instanciadas as variáveis necessárias para o envio dos dados do servidor para o cliente.
A variável “serverSocketSaida” é instanciada com uma nova porta de comunicação, a
porta 12345, que é diferente da porta de recebimento de dados. São instanciadas
também a variável “socketSaida” e a variável “dadosSaidaCliente”, que é a responsável
por armazenar e enviar os dados para o cliente. Para tanto, o código abaixo foi criado.
try {
serverSocketSaida = new ServerSocket(12345);
socketSaida = serverSocketSaida.accept();
DataOutputStream dadosSaidaCliente = new
DataOutputStream(socketSaida.getOutputStream());
} catch (IOException erro) {
87
JOptionPane.showMessageDialog(null, "Erro : " + erro);
}
Por último, os sockets de saída são fechados, assim como o canal de envio de
dados, como é mostrado no código abaixo:
try {
socketSaida.close();
serverSocketSaida.close();
dadosSaidaCliente.close();
} catch (IOException erro) {
JOptionPane.showMessageDialog(null, "Erro : " + erro);
}
O ciclo é reiniciado e retorna na parte onde o socket de entrada é aberto e
aguarda que haja conexão de algum cliente para um novo recebimento de dados.
Caso haja duas ou mais conexões simultâneas, o servidor será capaz de
responder a ambas, sem que aconteça perda de informações.
4.5 Desenvolvimento do software do cliente
O software do cliente, explicado nos diagramas mostrados anteriormente, foi
desenvolvido na linguagem de programação Java e na plataforma de desenvolvimento
Android. Como o objetivo deste software é facilitar o processo de compra, alguns
recursos do software devem ser usados dentro do estabelecimento, sendo eles: a
transmissão de dados via sockets, a leitura do código de barras e o armazenamento do
histórico de buscas. Existem alguns recursos usados antes do cliente chegar ao
estabelecimento, como a realização de ligações para o estabelecimento e sua localização
através dos recursos de mapas e GPS.
88
4.5.1 Interface do software
Ao abrir o software, a primeira tela mostra informações referentes ao
desenvolvedor. Para seguir para a tela de escolha de opções, basta pressionar o botão
“Ok”, como mostra a figura 39 (a).
A tela de opções apresenta as possíveis escolhas que podem ser feitas pelo
cliente, para isso ele deve selecionar a opção desejada e clicar no botão “Ok”. No final
da tela, também são apresentados os botões “Histórico”, onde são armazenadas as
buscas feitas pelo cliente, “Sobre”, que mostra algumas informações referentes ao
software, e o botão “Ajuda”, que explica como utilizar cada função do software. A
figura 39 (b) representa a tela de escolha de opções.
(a) (b)
Figura 39 - (a) Tela inicial do software do cliente. (b) Tela escolha de opções.
89
4.5.2 Transmissão dos dados via sockets
No software do cliente, a maneira de utilizar os sockets é bem parecida com a do
servidor. Primeiro são declaradas as variáveis dos sockets e da transmissão de dados,
sendo que para ambos são declaradas as variáveis de entrada e saída de dados, como é
mostrado abaixo:
Socket socketSaida, socketEntrada;
DataOutputStream dadosSaida;
DataInputStream dadosEntrada;
Depois de declaradas as variáveis, o socket de saída e a variável de envio de
dados são instanciados. Na instanciação do socket de saída é inserido o IP do
computador onde o servidor está sendo executado, IP 192.168.1.100, e a porta de
comunicação de recebimento de dados do servidor, porta 1234. Assim como ocorre no
servidor, todo o código é circundado pelas instruções try e catch, como podem ser visto
no código abaixo:
try {
socketSaida= new Socket(192.168.1.100, 1234);
dadosSaida = new DataOutputStream(socket1.getOutputStream());
} catch (Exception erro) {
Toast.makeText(this, "Erro" + erro, Toast.LENGTH_LONG).show();
}
Ao término do envio dos dados, o socket de saída e o canal de envio de dados é
fechado, como é mostrado abaixo:
try {
socketSaida.close();
dadosSaida.close();
} catch (Exception erro) {
Toast.makeText(this, "Erro" + erro, Toast.LENGTH_LONG).show();
90
}
Após enviar os dados, o software do cliente precisa receber a resposta vinda do
servidor. Para isso, o socket de entrada é instanciado, com o IP do computador onde está
o servidor e com a porta de envio de dados do servidor, e o canal de envio de dados,
como é mostrado abaixo:
try {
socketEntrada = new Socket(192.168.1.100, 12345);
dadosEntrada = new DataInputStream(socketEntrada.getInputStream());
} catch (Exception erro) {
Toast.makeText(this, "Erro" + erro, Toast.LENGTH_LONG).show();
}
Por último, o socket de saída e o canal de envio de dados são fechados, como é
mostrado no código abaixo:
try {
socketEntrada.close();
dadosEntrada.close();
} catch (Exception erro) {
Toast.makeText(this, "Erro" + erro, Toast.LENGTH_LONG).show();
}
O ciclo de comunicação é finalizado até que o cliente realize uma nova busca e
inicie novamente todo o processo de execução do socket.
4.5.3 Leitura do código de barras
Uma das opções para obter informações do produto como, por exemplo, o preço,
é ter o produto em mãos e utilizar o leitor de código de barras. Para realizar a leitura,
inicialmente é necessário ter instalado no celular o aplicativo Barcode Scanner.
91
Tendo o aplicativo instalado, a primeira coisa a ser feita é criar uma Intent para a
execução do Barcode e iniciá-lo através do método startActivityForResult, aguardando
o resultado retornado pelo aplicativo, como é mostrado abaixo:
int REQUEST_CODE = 0;
Intent ILerCodigoBarras = new Intent(
"com.google.zxing.client.android.SCAN");
startActivityForResult(ILerCodigoBarras, REQUEST_CODE);
Para recuperar o resultado, sobrescreve-se o método onActivityResult
aguardando que o parâmetro “requestCode” seja igual ao parâmetro
“REQUEST_CODE” passado no método startActivityForResult e verifica se o usuário
fez a leitura do código de barras. Para isso, compara-se a variável “resultCode” com a
constante “Activity.RESULT_OK”, se forem iguais, a leitura foi realizada com sucesso.
Já se a variável “resultCode” for igual a constante “Activity.RESULT_CANCELED”, a
leitura foi cancelada pelo o usuário.
Para obter o valor lido pelo Barcode, é necessário ler os parâmetros recebidos
pelo aplicativo. Para isso, armazena-se em uma variável o valor recebido do parâmetro
“SCAN_RESULT”, como é mostrado abaixo:
public void onActivityResult(int requestCode, int resultCode, Intent intent) {
if (requestCode == REQUEST_CODE) {
if (resultCode == Activity.RESULT_OK) {
codigoBarrasLido =
Intent.getStringExtra("SCAN_RESULT");
} else if (resultCode == Activity.RESULT_CANCELED) {
// Usuário não fez a leitura do código de barras
}
}
}
92
4.5.4 Armazenamento do histórico de buscas
Para controle do cliente, as buscas realizadas são armazenadas pelo aplicativo,
exceto as feitas através do leitor de código de barras. O armazenamento do histórico de
buscas é composto por três métodos: abrir o banco de dados, gravar os registros e o
fechar o banco de dados.
A primeira coisa a ser feita é declarar uma variável do tipo SQLiteDatabase que
será responsável pela manipulação das ações do banco de dados. Sua declaração é feita
conforme abaixo:
SQLiteDatabase bancoDados = null;
A próxima etapa é a criação de um método responsável pela abertura do banco
de dados. Neste método é definido o nome do banco de dados que será aberto ou criado,
se ainda não existir, através do comando openOrCreateDatabase, e a criação das tabelas
do banco, caso também não existam, pelo comando SQL CREATE TABLE IF NOT
EXISTS. O método “abrirBanco” é mostrado a seguir:
public void abrirBanco() {
try {
String nomeBanco = "bancoHistorico";
bancoDados = openOrCreateDatabase(nomeBanco,
MODE_WORLD_READABLE, null);
String sql = "CREATE TABLE IF NOT EXISTS historico "
+ "(id INTEGER PRIMARY KEY, produto TEXT, data
TEXT, horario TEXT)";
bancoDados.execSQL(sql);
} catch (Exception erro) {
mostrarAlerta("Erro", "Erro ao Abrir o Banco de dados: " +
erro.getMessage());
}
}
93
Após o banco de dados ter sido aberto ou criado, chama-se o segundo método, o
“gravarRegistros”. Nele é utilzado o comando SQL INSERT com as variáveis que serão
inseridas nas tabelas do banco, como é mostrado no código a seguir:
public void gravarRegistros() {
try {
String sql = "INSERT INTO historico (produto, data, horario)"
+ "VALUES ('" + nomeSelecionado + "','" + data + "','"
+ horario + "')";
bancoDados.execSQL(sql);
} catch (Exception erro) {
mostrarAlerta("Erro", "Erro ao Gravar Dados: " +
erro.getMessage());
}
}
Com os dados gravados no banco, chama-se o método “fecharBanco” que é o
responsável por finalizar a conexão ao banco de dados. O código fonte do método segue
abaixo:
public void fecharBanco() {
try {
bancoDados.close();
} catch (Exception erro) {
mostrarAlerta("Erro", "Erro ao Fechar o Banco de dados: " +
erro.getMessage());
}
}
A cada consulta de produto realizada pelo cliente é armazenado o nome do
produto, a data e a hora em que a busca foi realizada, sendo feito um registro para cada
produto, independente da quantidade de buscas feitas do mesmo produto.
94
4.5.5 Realização de ligações
Para realizar ligações através do aplicativo, a primeira coisa a se fazer é permitir
que o aplicativo utilize este recurso do telefone. Para isso, é necessário inserir a
permissão abaixo dentro da classe AndroidManifest.xml.
<uses-permission android:name="android.permission.CALL_PHONE"/>
Com a permissão inserida, cria-se um objeto da classe Uri e define-se como
parâmetro o telefone do local para onde será realizada a ligação. Basta trocar o valor
“xxx” pelo número do telefone desejado. Após isso, é criada uma Intent, que é
instanciada com os parâmetros Intent.ACCTION_CALL, responsável pela chamada, e o
objeto da classe Uri anteriormente instanciado. Por último, inicia-se a Intent, como é
mostrado abaixo:
Uri uriLigar = Uri.parse("tel:xxx");
Intent ILigar = new Intent(Intent.ACTION_CALL,uriLigar);
startActivity(ILigar);
4.5.6 Mapas e GPS
Ao utilizar mapas no Android, a primeira coisa a ser feita é adicionar as
permissões e a biblioteca do Google Maps na classe AndroidManifest.xml. As
permissões referem-se à conexão com a Internet e a posição atual do celular através do
GPS. O código abaixo demonstra a adição das permissões e da biblioteca dos mapas:
<uses-permission android:name = "android.permission.INTERNET"/>
<uses-permission android:name =
"android.permission.ACCESS_FINE_LOCATION"/>
<uses-library android:name = "com.google.android.maps"/>
95
Com a inserção do código acima na classe AndroidManifest.xml, cria-se um
arquivo com a extensão XML, onde o mapa será carregado. Para que o aplicativo
carregue os mapas é preciso criar uma chave gratuita do Google Maps, explicada no site
de desenvolvedores da Google: https://developers.google.com/android/maps-api-signup.
O trecho abaixo mostra o código da classe XML criada:
<com.google.android.maps.MapView
android:id="@+id/mapa"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:clickable="true"
android:enabled="true"
android:apiKey="0H6Txui98CIQkzpvoOopUjEicionigsBjpRC4tQ"
/>
Com o que já foi feito, os mapas serão carregados na aplicação, restando apenas
marcar a posição do estabelecimento e a posição atual do cliente no mapa. Para marcar a
posição do estabelecimento é preciso declarar uma variável do tipo MapView,
responsável por controlar as ações relacionadas ao mapa, uma do tipo
MapaLocalOverlay, classe criada pelo autor do projeto para fazer marcações no mapa
com o uso do Canvas, e uma variável do tipo GeoPoint, que receberá a latitude e a
longitude do local. Depois, instancia-se a variável “estabelecimento”, passando como
parâmetro o GeoPoint e o ícone que será desenhado no mapa. E através do método
mapa.getOverlays().add(estabelecimento), o símbolo escolhido para o estabelecimento
é marcado no mapa. O código abaixo demonstra a marcação do estabelecimento no
mapa:
private MapView mapa = (MapView) findViewById(R.id.mapa);
MapaLocalOverlay estabelecimento;
GeoPoint gpEstabelecimento = new GeoPoint((int) -18.974653,(int)-49.460065);
estabelecimento = new MapaLocalOverlay(gpEstabelecimento,
R.drawable.carrinho2);
mapa.getOverlays().add(estabelecimento);
96
Já para marcar a posição atual do cliente no mapa, o processo é mais complexo,
pois o aplicativo precisa reconhecer a mudança de posição do cliente como, por
exemplo, se ele estiver andando ou dirigindo.
O processo de marcação inicial da posição no mapa é bem semelhante ao do
estabelecimento, porém é utilizado um objeto da classe MyLocationOverlay, que é uma
classe do Android para desenhos de posições. Após isso, utiliza-se a mesma variável
“mapa”, criada anteriormente, para fazer a marcação no mapa, e logo em seguida, são
inseridos os métodos requestLocationUpdates e retornaLocationManager, sendo o
segundo método criado pelo autor do projeto, que irão requerer a posição do atual do
aparelho através da sua latitude e longitude.
O código abaixo mostra a marcação da posição no mapa e a utilização dos
métodos necessários para realizar esta marcação.
private MyLocationOverlay minhaLocalizacao = new MyLocationOverlay(this,
mapa);
mapa.getOverlays().add(minhaLocalizacao);
retornaLocationManager().requestLocationUpdates(LocationManager.GPS_PR
OVIDER, 0, 0, this);
private LocationManager retornaLocationManager() {
LocationManager locationManager = (LocationManager)
getSystemService(Context.LOCATION_SERVICE);
return locationManager;
}
Com o código acima inserido, o celular marcará no mapa a posição inicial do
cliente. Porém, é preciso sobrescrever o método onLocationChanged do Android, para
que a cada mudança de posição do cliente, o GPS envie ao celular sua nova posição e
possa atualizá-la no mapa.
97
Este método é acompanhado pelo método “posicao”, que faz a conversão da
latitude e da longitude em uma variável do tipo GeoPoint. O código abaixo mostra os
dois métodos.
@Override
public void onLocationChanged(Location location) {
posicao(location.getLatitude(), location.getLongitude());
}
public static GeoPoint posicao(double latitude, double longitude) {
GeoPoint geoPoint = new GeoPoint((int) (latitude * 1E6),
(int) (longitude * 1E6));
return geoPoint;
}
4.6 Testes
Com as funcionalidades do software já implementadas, serão realizados os testes
de funcionamento para cada uma das possíveis ações feitas pelo cliente, sendo elas:
buscar produto pelo nome, buscar produto pelo código de barras, produtos mais
buscados, ligar para o estabelecimento e como chegar ao estabelecimento.
4.6.1 Buscar produto pelo nome
Para realizar a busca de produtos pelo nome, primeiro escolhe-se a opção
“Buscar pelo Nome”. Na próxima tela, preenche-se o campo com o nome ou o tipo do
produto desejado e pressiona-se o botão “Buscar”, como é mostrado na figura 40 (a) e
(b).
98
(a) (b)
Figura 40 - (a) Escolha da opção “Buscar pelo Nome”. (b) Inserção do nome do produto.
Será mostrada a quantidade de produtos encontrados e uma lista com os nomes.
Para obter informações de algum produto específico, basta selecioná-lo e pressionar o
botão “Ok”. Na tela seguinte serão mostras as informações específicas do produto
selecionado, assim como um mapa do estabelecimento com a posição do produto
marcada com uma circunferência vermelha, como é mostrado na figura 41 (a) e (b).
99
(a) (b)
Figura 41 - (a) Escolha do produto. (b) Visualização das informações do produto.
4.6.2 Buscar produto pelo código de barras
Para obter informações do produto através do seu código de barras, escolhe-se a
opção “Buscar pelo Código de Barras”. Ao escolher esta opção, o aplicativo Barcode
Scanner abrirá e ficará aguardando que seja colocado um código de barras em frente à
câmera do celular para que ele realize a leitura, como apresenta a figura 42 (a) e (b).
100
(a) (b)
Figura 42 - (a) Escolha da opção “Buscar pelo código de barras”. (b) Leitura código de barras.
Após a leitura do código de barras, serão mostradas as informações do produto
correspondente, como mostra a figura 43.
Figura 43 - Visualização das informações do produto.
101
4.6.3 Produtos mais buscados
Para visualizar quais são os produtos mais buscados pelos clientes do
estabelecimento, seleciona-se a opção “Produtos Mais Buscados” e pressiona-se o botão
“Ok”. Na tela seguinte, aparecerá uma lista com os cinco produtos mais buscados por
todos os clientes. Para obter informações de algum destes produtos, basta selecioná-lo e
pressionar o botão “Ok”, como é mostrado na figura 44 (a) e (b).
(a) (b)
Figura 44 - (a) Escolha da opção “Produtos Mais Buscados”. (b) Escolha do produto.
Em seguinte, as informações do produto serão mostradas, como apresenta a
figura 45.
102
Figura 45 - Visualização das informações do produto.
4.6.4 Ligar para estabelecimento
Para realizar uma ligação para o estabelecimento comercial, basta selecionar a
opção “Ligar para o Estabelecimento” e pressionar o botão “Ok”. Automaticamente a
ligação será iniciada, podendo ser encerrada a qualquer momento pelo cliente. A figura
46 (a) e (b) mostra a realização da chamada.
103
(a) (b)
Figura 46 - (a) Escolha da opção “Ligar para o Estabelecimento”. (b) Realização da chamada.
4.6.5 Como chegar ao estabelecimento
Para visualizar os mapas e a posição atual do cliente no mapa, seleciona-se a
opção “Como Chegar?” e pressiona o botão “Ok”, como é mostrado na figura 47.
104
Figura 47 - Escolha da opção “Como Chegar?”.
A tela seguinte apresenta os mapas, inicialmente apresentados no modo satélite,
com a posição do comércio marcada com o símbolo de um carrinho de compras amarelo
e a posição atual do cliente com uma bolinha azul, como apresenta a figura 48 (a).
É possível alterar a visualização do modo satélite para o modo mapa. Para isso é
só clicar no botão “Menu” do aparelho celular e escolher a opção “Modo Mapa”.
Quando a visualização for alterada, a cor do símbolo do carrinho mudará para roxo,
como é mostrado na figura 48 (b).
105
(a) (b)
Figura 48 - (a) Visualização modo satélite. (b) Visualização modo mapa.
Outro recurso disponível nesta parte de mapas é a centralização do mapa tanto
na posição do comércio, quanto na posição do cliente. Para centralizar o mapa sobre o
comércio, clica-se no botão “Menu” do celular e depois no botão “Posição Comércio” e
para a posição atual do cliente, clica-se no botão “Minha Posição”, como é mostrado na
figura 49 (a) e (b).
106
(a) (b)
Figura 49 - (a) Mapa centralizado no estabelecimento. (b) Mapa centralizado no cliente
4.7 Conclusão
Neste capítulo foram apresentados os diagramas de funcionamento do projeto e
o desenvolvimento e testes dos softwares.
As threads foram escolhidas em vez dos métodos, pois elas atendem a múltiplas
conexões, ou seja, se vários clientes buscarem informações simultaneamente, ambos
obterão resposta do servidor. Já o uso dos sockets para a comunicação entre os
softwares, utiliza o IP do servidor e a porta de comunicação do servidor e do software
do cliente, sendo possível adaptar o tanto IP do servidor para o IP do computador em
que o software será instalado, quanto as portas de comunicação.
Para a utilização dos recursos de mapa e GPS, foram encontradas algumas
dificuldades iniciais, como por exemplo, a criação das chaves necessárias para carregar
os mapas na aplicação, sendo que a chave do emulador, software utilizado para emular o
aplicativo no computador, é diferente da chave usada para aplicação que será instalada
107
no celular. Para resolver este problema, foi necessária a criação de ambas as chaves,
tanto a do emulador quanto a do aparelho real. As informações detalhadas quanto a
criação e utilização das chaves do Google Maps podem ser encontradas em
https://developers.google.com/android/maps-api-signup?hl=pt-BR.
Com o término do desenvolvimento do projeto, foi possível chegar ao resultado
esperado, sendo que ambos os softwares estão funcionando perfeitamente e realizando
as funções propostas no projeto.
108
5 Conclusão
Após o término do desenvolvimento deste trabalho, chegou-se a conclusão de
que é possível desenvolver um sistema que simplifique o processo de compras feito pelo
consumidor.
Com o estudo da plataforma Android, foi possível perceber que sua arquitetura é
bastante flexível possibilitando a integração de aplicações, sejam elas aplicações nativas
do sistema ou não, ou até mesmo, substituir aplicações nativas por uma criada por
terceiros. Além disso, o sistema operacional do Android é baseado em Linux, portanto o
gerenciamento de memória e de processos é feito pelo Linux, possibilitando que várias
aplicações sejam executadas simultaneamente sem que o usuário perceba.
Dentre as aplicações que podem ser integradas, foram utilizadas a API do
Google Maps e os recursos de localização de GPS. Um dos fatores que pesa
negativamente para utilização do Google Maps é a necessidade de uma conexão com a
Internet para fazer o download dos mapas, todas as vezes em que a interface dos mapas
é carregada. Porém, possuindo conexão com a Internet, o carregamento dos mapas
acontece quase que instantâneo. O processo de integração dessas API na aplicação
Android é um processo relativamente simples e que não gera muitas dificuldades.
A escolha da linguagem Java foi adequada para o desenvolvimento dos
softwares, atendendo todas as necessidades previstas no projeto. Outros recursos da
linguagem que foram utilizadas e funcionaram da maneira esperada foram as threads e
os sockets, possibilitando conexões por parte dos clientes.
As facilidades encontradas durante o projeto foram o conhecimento prévio da
linguagem Java, facilitando a construção do servidor e também do software do cliente
(por a linguagem utilizada no Android ser o Java) e da linguagem para dispositivos
móveis Java ME, já tendo uma noção razoável de programação para celulares. .
109
O funcionamento dos softwares atenderam aos objetivos esperados, sendo que
ambos estão funcionando da maneira adequada e comunicando entre si sem que haja
perca dos dados durante a troca de informações e possibilitando que vários clientes
conectem simultaneamente ao servidor. Para a comunicação é possível adaptar o
endereço de IP do servidor no software do cliente, bastando trocá-lo pelo endereço
desejado.
Para realizar a instalação do software nos celulares dos clientes, pode-se
disponibilizar sua instalação em algum site qualquer ou dentro do próprio
estabelecimento comercial, sendo que algum funcionário ficaria encarregado de instalar
o software e tirar possíveis dúvidas quanto a sua utilização.
Quanto à segurança do sistema, o cliente que irá utilizar o software não precisa
se preocupar, pois o programa faz apenas a troca de informações com o servidor, não
expondo os arquivos particulares do usuário a ninguém.
5.1 Trabalhos futuros
Após o desenvolvimento dos softwares, alguns aprimoramentos podem ser feitos
para melhorar sua funcionalidade. Dentre os quais, pode-se destacar:
a) Inserção de novos atributos para os produtos.
b) Atualização das imagens da localização dos produtos, sendo que elas
encontram-se no software do cliente, caso algum produto seja mudado de
prateleira.
c) Possibilidade de traçar a rota no mapa entre a posição do cliente e a posição
do estabelecimento comercial.
d) Possibilidade de cadastrar a lista de compras, aproveitando os recursos do
banco de dados SQLite, antes de chegar ao estabelecimento.
110
6 Referências
ALVARENGA, J. H. XML - Extensible Markup Language. AmigoNerd.net, 2005.
Disponível em: <http://amigonerd.net/trabalho/24621-xml-extensible-markup-
language>. Acesso em: 28 Março 2012.
ALVAREZ, M. A. O que é XML?. Criar Web, 2004. Disponível em:
<http://www.criarweb.com/artigos/203.php>. Acesso em: 28 Março 2012.
AMORIM, A. D. D. Android, uma visão geral. Belo Horizonte: [s.n.], 2011.
ANISZCZYK, C.; GALLARDO, D. Introdução à plataforma Eclipse. IBM, 2012.
Disponível em: <http://www.ibm.com/developerworks/br/library/os-eclipse-platform/>.
Acesso em: 27 Março 2012.
ARAÚJO, E. C. J. D. UP - Um jogo educativo para celulares destinado a crianças
com síndrome. João Pessoa: [s.n.], 2010.
ARAÚJO, F. B. D. Desenvolvimento de softwares para dispositivos móveis. Rio de
Janeiro: [s.n.], 2006.
BALSEMÃO, F. T. Gerência e monitoramento de redes através de dispositivos
móveis. Porto Alegre: [s.n.], 2008.
BALTAZAR, M. Tutorial: Utilização do Sqlite no Android. pplware, 2012.
Disponível em: <http://pplware.sapo.pt/smartphones/android/tutorial-utilizao-do-sqlite-
no-android-parte-i/>. Acesso em: 13 Abril 2012.
BAPTISTA, L.; PALANGANI, M.; DELDOTO, T. Java Virtual Machine (JVM).
2009.
BASSI, E. IDE - Ambiente integrado de desenvolvimento. Hturbo, 2011. Disponível
em:
<http://www.cezar.hturbo.com.br/cezar15/index.php?option=com_content&view=sectio
n&layout=blog&id=11&Itemid=54>. Acesso em: 10 Abril 2012.
BEDANI, E. R. Gestão de tempo, o grande desafio dos tempos modernos.
Administradores.com, 2011. Disponível em:
<http://www.administradores.com.br/informe-se/carreira-e-rh/gestao-de-tempo-o-
grande-desafio-dos-tempos-modernos/42763/>. Acesso em: 10 Agosto 2012.
BESTANDROID. Top Android app: Barcode Scanner. Best Android App Review,
2009. Disponível em: <http://www.bestandroidappsreview.com/2009/12/top-android-
app-barcode-scanner.html>. Acesso em: 26 Abril 2012.
BRAZ, C. C. M. Introdução à linguagem Java. Campo Grande: [s.n.], 2004.
111
BUENO, A. D. Apostila de programação orientada a objetos em C++. Santa
Catarina: [s.n.], 2002.
BUGARIN, G.; BORGES, L.; DATTOLI, F. Plataformas de desenvolvimento para
celulares. Wikidot, 2009. Disponível em:
<http://pesquompile.wikidot.com/plataformas-desenvolvimento-celular>. Acesso em:
22 Março 2012.
CARACIOLO, M. P. Desenvolvendo aplicações Python para Symbian OS.
DevMedia, 2009. Disponível em: <http://www.devmedia.com.br/desenvolvendo-
aplicacoes-python-para-symbian-os/11644>. Acesso em: 16 Março 2012.
CROCE FILHO, R. D.; RIBEIRO, C. E. Informática - Programação de
computadores. 4ª. Ed. São Paulo: [s.n.], 2010.
SILVA, L. A. Programando passo a passo. Rio de Janeiro: [s.n.], 2010.
DEVMEDIA. SQLite no Android. DevMedia, 2011. Disponível em:
<http://www.devmedia.com.br/sqlite-no-android-artigo-web-mobile-34/19201>. Acesso
em: 13 Abril 2012.
ECLIPSE. Eclipse platform technical overview. Eclipse.org, 2007. Disponível em:
<http://www.eclipse.org/articles/Whitepaper-Platform-3.1/eclipse-platform-
whitepaper.html>. Acesso em: 26 Abril 2012.
FARIA, A. D. O. Programe seu Android. Linux Magazine, São Paulo, n. 43, p. 73-77,
Junho 2008.
FREITAS, O. C. D. Vantagens do Java. OhanaFreitas, 2010. Disponível em:
<http://ohanafreitas.blogspot.com.br/2010/08/vantagens-do-java-por-que-estudar-
essa.html>. Acesso em: 26 Abril 2012.
GONÇALVES, E. Dominando o Eclipse. 1ª. Ed. Rio de Janeiro: Ciência Moderna,
2006.
GOOGLE. Google Maps, 2012. Disponível em: <http://maps.google.com.br/>. Acesso
em: 4 Maio 2012.
HASLINGER, M. C. Protótipo para localização de pontos de referência na cidade
de Chapecó utilizando Google Android e Google Maps. Chapecó: [s.n.], 2009.
HOPSON, K. C.; INGRAM, S. E. Desenvolvendo applets com Java. 1ª. Ed. [S.l.]:
Campus, 1997.
HUANG, J. A Java developer. Braveo, 2010. Disponível em:
<http://braveo.blogspot.com.br/2010/07/netbeans-runtime-container.html>. Acesso em:
23 Abril 2012.
112
IERUSALIMSCHY, R. Uma introdução à programação em Lua, Rio de Janeiro:
[s.n.], 2009.
JOHNSON, T. M. Java para dispositivos móveis. São Paulo: Novatec, 2007.
LECHETA, R. R. Google Android: aprenda a criar aplicações para dispositivos
móveis com o Android SDK. São Paulo: Novatec, 2009.
LUA. Lua. A linguagem de programação Lua, 2011. Disponível em:
<http://www.lua.org/portugues.html>. Acesso em: 17 Março 2012.
MELO, M. Google Maps e sua empresa. Webtask, 2009. Disponível em:
<http://www.webtask.com.br/artigo/googlemaps-e-sua-empresa>. Acesso em: 4 Maio
2012.
MICROSOFT. Por que atualizar para o SQL Server 2008?. Microsoft, 2011.
Disponível em: <http://www.microsoft.com/sqlserver/2008/pt/br/why-upgrade.aspx>.
Acesso em: 3 Abril 2012.
MORIMOTO, C. E. Smartphones: a história do Windows Mobile. Guia do
Hardware, 2010. Disponível em: <http://www.hardware.com.br/dicas/historia-windows-
mobile.htmlCarlos E. Morimoto>. Acesso em: 22 Março 2012.
NETBEANS. Um breve histórico do NetBeans. NetBeans, 2011. Disponível em:
<http://netbeans.org/about/history_pt_BR.html>. Acesso em: 27 Março 2012.
NÓBREGA, J. 2010 vai ser o ano das aplicações móveis. Computer World, 2010.
Disponível em: <http://www.computerworld.com.pt/2010/04/08/2010-vai-ser-o-ano-
das-aplicacoes-moveis/>. Acesso em: 10 Agosto 2012.
OFICINA DA NET. O que é o NetBeans?. Oficina da Net, 2008. Disponível em:
<http://www.oficinadanet.com.br/artigo/1061/o_que_e_o_netbeans>. Acesso em: 27
Março 2012.
OKADA, T. Uma introdução aos sistemas operacionais móveis. Guia do Hardware,
2011. Disponível em: <http://www.hardware.com.br/artigos/sistemas-operacionais-
mobile>. Acesso em: 22 Março 2012.
OLIVEIRA, J. D.; PHILERENO, J. A. SQL. Igrejinha: [s.n.], 2005.
OLIVEIRA, K. M. D. Instalando e atualizando o plugin ADT no Eclipse.
Klebermota, 2010. Disponível em:
<http://www.klebermota.eti.br/2010/02/08/installing-and-updating-adt/>. Acesso em: 2
Abril 2012.
OLIVEIRA, M. R. F. D. Adequação de um Framework para suportar realidade
virtual em dispositivos móveis, Uberlândia: [s.n.], 2011.
113
OLIVEIRA, R. Introdução ao Windows Mobile. Programação Android e.Net, 2010.
Disponível em: <http://romarconsultoria.blogspot.com.br/2010/03/introducao-ao-
windows-mobile.html>. Acesso em: 22 Março 2012.
ORACLE. Banco de dados – SGBD. SPK, 2006. Disponível em:
<http://www.spk.com.br/bancodados.asp>. Acesso em: 2 Abril 2012.
ORACLE. O que é a tecnologia Java e por que é necessária?. Java, 2011. Disponível
em: <http://www.java.com/pt_BR/download/faq/whatis_java.xml>. Acesso em: 15
Abril 2012.
PAULA FILHO, W. D. Introdução a programação na linguagem Java. Uberlândia:
[s.n.], 2008.
PRADO, L. M. Integração do sistema de controle de versão subversion (SVN) com
o IDE NetBeans. Florianópolis: [s.n.], 2006.
PRADO, S. Introdução ao funcionamento interno do Android. SergioPrado.org,
2011. Disponível em: <http://sergioprado.org/2011/08/15/introducao-ao-
funcionamento-interno-do-android/>. Acesso em: 26 Abril 2012.
RAMOS, G. D. O.; TEODOROWITSCH, R. Threads em Java. Gravataí: [s.n.], 2009.
RAMOS, R. B. Aplicativos de banco de dados. Alunos de TI, 2011. Disponível em:
<http://www.alunosdeti.com.br/2011/?pg=noticia&id=12461>. Acesso em: 2 Abril
2012.
RODRIGUES, D. M. Programando para Symbian OS. São Paulo: [s.n.], 2007.
ROMÃO, B. V. A história da linguagem C. Portal da programação, 2002. Disponível
em: <http://www.portaldaprogramacao.com/artigos2.asp?n=79>. Acesso em: 16 Março
2012.
ROSSUM, G. V. Tutorial de Python. São Paulo: [s.n.], 2004.
SAUVÉ, J. P.; SANTOS JÚNIOR, J. M. R. Threads em Java. Aracajú: [s.n.], 2000.
SOUSA, L. D. S. J2ME - Plataforma Java para dispositivos móveis. Barra dos
Garças: [s.n.], 2010.
TEIXEIRA, E. Introdução ao Eclipse (Java). Programero, 2008. Disponível em:
<http://programero.blogspot.com.br/2008/07/introduo-ao-eclipse-java.html>. Acesso
em: 28 Março 2012.
