Utilização De Recursos Java Na Plataforma Android Para Facilitar O Processo De...

Transcript

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 3 Conclusão ................................................................................................................................ 28 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 3.2.4 3.2.5 3.2.6 JVM ........................................................................................................................................... 38 Garbage Collection .................................................................................................................... 39 Sockets ...................................................................................................................................... 40 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 4 Conclusão ................................................................................................................................ 53 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 5.1 6 CONCLUSÃO ................................................................................................................ 108 Trabalhos futuros .................................................................................................................. 109 REFERÊNCIAS ............................................................................................................. 110 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). 16 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). 17 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. 18 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. 19 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. 20 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 21 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, 22 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). 23 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). 24 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 25 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). 26 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). 27 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. 28 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). 29 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). 30 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. 31 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. 32 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). 33 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 plugins. 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 34 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 35 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. 36 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). 37 • 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 38 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). 39 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). 40 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: aberturaleitura-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). 41 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. 42 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). 43 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. 44 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 45 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. 46 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). 47 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. 48 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 49 (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). 50 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). 51 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 52 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. 53 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. 54 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. 55 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. 56 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. 57 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. 58 Caso de uso Excluir produto. Ator principal Usuário. Pré-condição Ter feito log-in. 1. Selecionar produto a ser excluído. 2. Excluir produto. Fluxo normal Fluxos excepcionais Fluxos alternativos Produto excluído com sucesso. Pós-condição 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. 1. Visualizar a tabela com os produtos mais buscados. Fluxo normal 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. 59 Caso de uso Abrir/Fechar conexão. Ator principal Usuário. Pré-condição Ter feito log-in. 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. Fluxo normal Fluxos excepcionais Fluxos alternativos Porta de conexão aberta ou fechada. Pós-condição 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. 60 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 Usuário alterado com sucesso. Pós-condição 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. 61 Caso de uso Excluir usuário. Ator principal Administrador. Pré-condição Ter feito log-in. 1. Selecionar usuário a ser excluído. 2. Excluir usuário. Fluxo normal Fluxos excepcionais Fluxos alternativos Usuário excluído com sucesso. Pós-condição 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. 62 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. 63 Figura 12 - Diagrama de caso de uso do cliente. 64 Caso de uso Buscar produto pelo nome. Ator principal Cliente. Pré-condição Estar conectado a rede sem fio do estabelecimento. Fluxo normal 1. 2. 3. 4. 5. Inserir nome do produto a ser buscado. Enviar o nome inserido para o servidor. Receber os produtos encontrados. Escolher o produto dentre os encontrados. Visualizar as informações do produto. Fluxos excepcionais 3. Produto não encontrado. 3. a. Inserir nome do produto novamente. Fluxos alternativos Visualização das informações do produto. Pós-condição 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. 2. 3. 4. Iniciar o Barcode Scanner. Ler o código de barras do produto. Enviar o código de barras para o servidor. 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. 65 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 Visualização das informações do produto. Pós-condição 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. 66 Caso de uso Visualizar mapa. Ator principal Cliente. Pré-condição Estar conectado a Internet ou ter plano de dados no celular. 1. Carregar os mapas no celular 2. Visualizar os mapas. Fluxo normal Fluxos excepcionais Fluxos alternativos 1. Mudar exibição do mapa. 1. a. Visualizar mapa modo “mapa”. 2. a. Visualizar mapa no modo “satélite”. Visualização dos mapas. Pós-condição 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. 67 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. 1. Carregar mapas no celular. 2. Visualizar a posição do cliente no mapa. 3. Atualizar a mudança de posição do cliente. Fluxo normal 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 login, 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. 68 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. 69 Figura 16 – Diagrama de sequência do usuário - Editar produto. Figura 17 - Diagrama de sequência do usuário - Excluir produto. 70 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 71 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. 72 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. 73 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. 74 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. 75 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. 76 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. 77 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). 78 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. 79 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 80 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. 81 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 82 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. 83 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++; } 84 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: 85 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) { 86 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. 87 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. 88 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(); 89 } 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. 90 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 } } } 91 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()); } } 92 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. 93 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. 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: 94 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 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); 95 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. 96 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). 97 (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). 98 (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). 99 (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. 100 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. 101 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. 102 (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. 103 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). 104 (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). 105 (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 106 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. 107 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. . 108 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. 109 6 Referências ALVARENGA, J. H. XML - Extensible Markup Language. AmigoNerd.net, 2005. Disponível em: . Acesso em: 28 Março 2012. ALVAREZ, M. A. O que é XML?. Criar Web, 2004. Disponível em: . 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: . 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: . 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: . Acesso em: 10 Abril 2012. BEDANI, E. R. Gestão de tempo, o grande desafio dos tempos modernos. Administradores.com, 2011. Disponível em: . Acesso em: 10 Agosto 2012. BESTANDROID. Top Android app: Barcode Scanner. Best Android App Review, 2009. Disponível em: . Acesso em: 26 Abril 2012. BRAZ, C. C. M. Introdução à linguagem Java. Campo Grande: [s.n.], 2004. 110 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: . Acesso em: 22 Março 2012. CARACIOLO, M. P. Desenvolvendo aplicações Python para Symbian OS. DevMedia, 2009. Disponível em: . 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: . Acesso em: 13 Abril 2012. ECLIPSE. Eclipse platform technical overview. Eclipse.org, 2007. Disponível em: . 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: . 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: . 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: . Acesso em: 23 Abril 2012. 111 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: . Acesso em: 17 Março 2012. MELO, M. Google Maps e sua empresa. Webtask, 2009. Disponível em: . Acesso em: 4 Maio 2012. MICROSOFT. Por que atualizar para o SQL Server 2008?. Microsoft, 2011. Disponível em: . Acesso em: 3 Abril 2012. MORIMOTO, C. E. Smartphones: a história do Windows Mobile. Guia do Hardware, 2010. Disponível em: . Acesso em: 22 Março 2012. NETBEANS. Um breve histórico do NetBeans. NetBeans, 2011. Disponível em: . 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: . Acesso em: 10 Agosto 2012. OFICINA DA NET. O que é o NetBeans?. Oficina da Net, 2008. Disponível em: . Acesso em: 27 Março 2012. OKADA, T. Uma introdução aos sistemas operacionais móveis. Guia do Hardware, 2011. Disponível em: . 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: . 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. 112 OLIVEIRA, R. Introdução ao Windows Mobile. Programação Android e.Net, 2010. Disponível em: . Acesso em: 22 Março 2012. ORACLE. Banco de dados – SGBD. SPK, 2006. Disponível em: . Acesso em: 2 Abril 2012. ORACLE. O que é a tecnologia Java e por que é necessária?. Java, 2011. Disponível em: . 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: . 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: . 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: . 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: . Acesso em: 28 Março 2012. 113