BLUETOOTH COMO ESTRUTURA DE COMUNICAÇÃO...
54
UNIVERSIDADE SÃO FRANCISCO Curso de Engenharia de Computação RILDO DOS SANTOS GONÇALVES BLUETOOTH COMO ESTRUTURA DE COMUNICAÇÃO APLICADA A CAMPANHAS PUBLICITÁRIAS Itatiba 2010
Transcript of BLUETOOTH COMO ESTRUTURA DE COMUNICAÇÃO...
UNIVERSIDADE SÃO FRANCISCO
Curso de Engenharia de Computação
RILDO DOS SANTOS GONÇALVES
BLUETOOTH COMO ESTRUTURA DE COMUNICAÇÃO
APLICADA A CAMPANHAS PUBLICITÁRIAS
Itatiba
2010
i
RILDO DOS SANTOS GONÇALVES - 002200600599
BLUETOOTH COMO ESTRUTURA DE COMUNICAÇÃO
APLICADA A CAMPANHAS PUBLICITÁRIAS
Monografia apresentada à disciplina Trabalho
de Conclusão de Curso, do curso de
Engenharia de Computação da Universidade
São Francisco, como exigência para conclusão
do curso de graduação.
Orientador: Prof. Marcelo Augusto
Gonçalves Bardi
Itatiba
2010
ii
GONÇALVES, Rildo dos Santos. BLUETOOTH COMO ESTRUTURA DE
COMUNICAÇÃO APLICADA A CAMPANHAS PUBLICITÁRIAS
Monografia defendida e aprovada em 09 de Dezembro de 2010.
iii
Dedico este trabalho aos meus pais, Benedito Gonçalves e
Dalva A. dos Santos Gonçalves e aos meus amigos da
universidade por estarem ao meu lado em horas tão difíceis e ao
mesmo tempo tão gratificantes.
iv
AGRADECIMENTOS
Agradeço a realização deste trabalho a minha família por me darem o suporte
necessário até aqui. Eu integro a minha família natural, meus queridos amigos da universidade
que por incontáveis vezes me incentivaram a continuar quando eu pensava em desistir.
Agradeço também ao meu orientador, Marcelo Augusto Gonçalves Bardi, por persistir
e acreditar na elaboração desse trabalho. Obrigado.
v
“Não preciso de modelos, não preciso de heróis. Eu
tenho meus amigos...”
(Renato Russo)
vi
RESUMO
Bluetooth é uma tecnologia de comunicação por rádio de baixa freqüência e baixo alcance,
desenvolvida para efetuar troca de dados sem fio a curtas distâncias. Essa tecnologia
possibilita conectar dispositivos que estão próximos facilmente, simplificando tarefas do dia a
dia que até então necessitavam da passagem de cabos pelo meio da sala para interligar os
dispositivos utilizados. Atualmente, a grande maioria de aparelhos celulares traz o Bluetooth
integrado. O Bluetooth nasceu da união de cinco empresas da área de tecnologia que
buscavam uma solução para conectar equipamentos móveis e que não gastasse muita energia
para economizar as baterias desses equipamentos. Hoje, várias companhias integram o SIG,
sigla em inglês para Grupo Especial de Interesse Bluetooth. Outra tecnologia que abrange a
grande maioria de dispositivos móveis é a linguagem de programação Java. O Java foi
desenvolvido, inicialmente, para rodar em tudo que tivesse um microprocessador, mas
explodiu mesmo com o surgimento da World Wide Web, onde foi utilizado para criar páginas
de conteúdo dinâmico. A partir de então, o Java começou a ser utilizado também em
dispositivos móveis, aparelhos receptores de sinal de TV Digital, para construção de jogos e
muito mais. Boa parte desse sucesso se deve a importante característica do Java de não
depender da plataforma onde irá executar, desde que exista uma máquina virtual Java para
essa plataforma. Dada a grande importância dos dispositivos móveis existentes hoje, esse
trabalho vem agregar essas duas tecnologias em um aplicativo que possibilite a distribuição de
material de propaganda e de informação a usuários que tenham celulares ou smartphones para
que sejam utilizados para visualizar esse conteúdo e que ainda, possam interagir com a
aplicação no intuito de fazer pesquisas ou obter informações específicas sobre produtos.
Palavras-chave: Bluetooth; Java ME; Java SE; Linux.
vii
ABSTRACT
Bluetooth is a radio communications technology of low frequency and low range, designed to
exchange data wireless over short distances. This technology allows connecting devices that
are coming easily, simplifying the daily tasks that until now required the passage of cables
through the middle of the room to connect the devices. Currently, the vast majority of mobile
devices brings the Bluetooth communication integrated. Bluetooth was born for five
technology companies that was seeking a solution for connecting mobile devices and do not
spend much energy to conserve battery power such equipment. Today, several companies
integrate Bluetooth SIG, abbreviation for Bluetooth Special Interest Group. Another
technology that covers the vast majority of mobile devices is the Java programming language.
Java was developed initially to run on everything that had a microprocessor, but came to be
known with the emergence of the World Wide Web, which was used to create dynamic
content pages. Since then, Java was being used also in mobile devices, receiver devices
Digital TV signal, to build games and more. Much of this success is due to the important
characteristic of Java is independent of the platform where it will run, since there is a Java
virtual machine for that platform. Given the importance of mobile devices available today,
this work is to aggregate these two technologies in an application that enables the distribution
of advertisement material and information to users who have smartphones or cell phones to be
used to view such content and it also can interact with the application in order to do research
or obtain information about specific products.
keywords: Bluetooth; Java ME; Java SE; Linux.
viii
SUMÁRIO
1 INTRODUÇÃO .................................................................................................................................. 1
1.1 Objetivos ............................................................................................................................................................ 2
1.2 Estrutura do trabalho ................................................................................................................................... 2
2 ASPECTOS TEÓRICOS ...................................................................................................................... 3
2.1 Dispositivos Móveis ....................................................................................................................................... 3
2.2 A Tecnologia Bluetooth ................................................................................................................................ 3
2.2.1 Arquitetura Bluetooth .................................................................................. 4
2.2.2 Pilhas de protocolos do Bluetooth ............................................................... 5
2.3 JAVA ...................................................................................................................................................................... 7
2.3.1 Java Standard Edition ............................................................................... 10
2.3.2 Java Micro Edition .................................................................................... 11
2.3.3 API Bluetooth Java ................................................................................... 12
2.4 Linux ................................................................................................................................................................. 24
3 METODOLOGIA DE DESENVOLVIMENTO...................................................................................... 25
3.1 Ferramentas Utilizadas ............................................................................................................................. 25
3.2 Modelagem do Sistema ............................................................................................................................. 26
3.2.1 Descrição do Sistema ................................................................................ 26
3.2.2 Funcionalidades e Diagramas de Casos de Uso ........................................ 27
3.2.3 Diagramas de Seqüência ........................................................................... 28
3.2.4 Diagramas de Classes ................................................................................ 29
3.2.5 Protótipo das Telas do Aplicativo Servidor .............................................. 30
3.2.6 Estruturação das Bases de Dados .............................................................. 32
3.3 Codificação do Aplicativo Cliente .......................................................................................................... 33
3.4 Codificação do Aplicativo Servidor ...................................................................................................... 36
4 Resultados e discussões ............................................................................................................... 38
5 Conclusões .................................................................................................................................... 40
5.1 Sugestões de Trabalhos Futuros ........................................................................................................... 40
6 REFERÊNCIAS BIBLIOGRÁFICAS..................................................................................................... 41
ix
LISTA DE SIGLAS
BCC – Bluetooth Control Center
BNEP – Bluetooth Network Encapsulation Protocol
CDC – Connected Device Configuration
CLDC – Connected, Limited Device Configuration
GPL – General Public License
HCI – Host Controller Interface
HID – Human Interface Device Protocol
IEEE – Institute of Electrical and Electronic Engineers
IDE – Integrated Development Environment
IDE – Integrated Development Environment
IP – Internet Protocol
JCP – Java Community Process
JDK – Java Development Kit
JRE – Java Runtime Environment
JSR – Java Specification Request
JVM – Java Virtual Machine
L2CAP – Logical Link Control and Adaptation Protocol
OBEX – Object Exchange
PAN – Personal Area Network
PPP – Point to Point Protocol
RFCOMM – Radio Frequency Communication
RI – Reference Implementation
SDDB – Service Discovery Database
SDP – Service Discovery Protocol
SDK – Software Development Kit
SIG – Special Interest Group
TCK – Technology Compatibility Kit
TCS-BIN – Telephony Control Protocol Specification
UUID – Universal Unique Identifier
UDP – User Datagram Protocol
WAP – Wireless Access Protocol
x
Lista de Figuras
Figura 1 - Scatternet formada por duas piconets ............................................................ 4
Figura 2 - Camadas do Protocolo Bluetooth ................................................................... 6
Figura 3 - Processo de criação de um programa Java .................................................... 9
Figura 4 - Plataforma Java ............................................................................................. 9
Figura 5 - Configurações e Perfis mais comuns ........................................................... 11
Figura 6 - SDDB e dois Registros de Serviços suportados .......................................... 18
Figura 7 - Atributos em um ServiceRecord .................................................................. 18
Figura 8 - Dongle Bluetooth ......................................................................................... 25
Figura 9 - Visão geral das funcionalidades dos atores ................................................. 27
Figura 10 - Funcionalidades do ator administrador ...................................................... 27
Figura 11 - Funcionalidades do ator usuário ................................................................ 28
Figura 12 - Diagrama de seqüência de consulta de produtos ....................................... 28
Figura 13 - Diagrama de seqüência para enviar uma campanha .................................. 29
Figura 14 - Diagrama de classes aplicativo cliente ...................................................... 29
Figura 15 - Diagrama de classes do aplicativo servidor ............................................... 30
Figura 16 - Tela de login .............................................................................................. 31
Figura 17 - Tela Principal ............................................................................................. 31
Figura 18 - Tela de produtos ......................................................................................... 32
Figura 19 - Aplicativo Cliente ...................................................................................... 34
Figura 20 - Telas diversas do aplicativo ....................................................................... 35
Figura 21 - Procura de dispositivos .............................................................................. 36
Figura 22 - Dispositivo encontrado .............................................................................. 37
Figura 23 - Envio de uma mensagem publicitária ao usuário....................................... 38
Figura 24 - Envio de uma solicitação de pesquisa ao servidor ..................................... 39
xi
Lista de Tabelas
Tabela 1 - Os perfis do Bluetooth ................................................................................... 7
Tabela 2 - Kits de Desenvolvimento e suas Empresas ................................................. 12
Tabela 3 - Modos de visibilidade do dispositivo Bluetooth ......................................... 15
Tabela 4 - Classes de dispositivos Bluetooth ................................................................ 16
Tabela 5 - UUID referentes aos protocolos Bluetooth .................................................. 19
Tabela 6 - UUID referentes aos Perfis Bluetooth ......................................................... 19
Tabela 7 - Casos de uso do ator administrador ............................................................. 27
Tabela 8 - Casos de uso do ator usuário ....................................................................... 28
Tabela 9 - Estrutura Base de Dados .............................................................................. 32
1
1 INTRODUÇÃO
Nos últimos anos, a sociedade tem vivenciado uma avalanche de dispositivos
eletrônicos com as mais variadas funcionalidades, que vem contribuindo para tornar nossas
vidas mais práticas e prazerosas. O maior expoente entre esses dispositivos é o celular, que já
se tornou um companheiro inseparável na vida de muitas pessoas. Já existe até uma doença
ligada a sua falta: a nomofobia, que é o medo do indivíduo de ficar incomunicável ou
desconectado (FANTÁSTICO, 2010).
De acordo com estatísticas de outubro de 2010, no Brasil já existe mais celulares que
habitantes (UOL, 20010) e os índices não param de crescer. Portanto, utilizar o celular como
forma de negócio é cada vez mais comum.
Assim, investir em aplicativos para celulares e smartphones é investir em um mercado
que está certamente aquecido e que continuará ainda a manter essa tendência por muito
tempo. Considerando que empresas como a Apple® e a Google
® estão investindo pesado em
aplicativos para essas plataformas indica que esse mercado dará muitos frutos a
programadores que tenham boas idéias para problemas do dia a dia e a usuários que contam
com as facilidades proporcionadas.
O Bluetooth é uma tecnologia que vem sendo muito utilizada em dispositivos móveis e
tem sido eficaz naquilo que se propõe: conectar equipamentos de diversos tipos e fabricantes
facilmente e sem o uso de cabos e instalação de softwares específicos.
Java é uma linguagem de programação que também tem sido largamente usada para
desenvolvimento de aplicativos para dispositivo de capacidade de processamento e
armazenamento reduzidos como celulares.
O celular é o equipamento que mais freqüentemente utiliza aplicativos Java e também
o que mais faz uso da comunicação por Bluetooth, seja para transferência de arquivos ou para
escutar músicas com um fone de ouvido sem fios. Muitas funcionalidades ainda podem ser
agregadas, facilitando cada vez mais o dia-a-dia das pessoas. Em face disso, esse projeto
busca o desenvolvimento de um aplicativo que transforme o celular em um panfleto eletrônico
que receba informações referentes ao ambiente em que se encontra.
Por traz do desenvolvimento desse aplicativo, está a oportunidade do estudo do
desenvolvimento de softwares em Java utilizando Bluetooth como meio de comunicação nas
plataformas Desktop e de dispositivos móveis.
2
1.1 Objetivos
Esse trabalho tem por objetivo a construção de um aplicativo que permita que um
aparelho celular possa trocar informações de caráter promocional e informativo com um
computador onde esteja instalado o processo servidor sendo executado sobre a plataforma
GNU/Linux. As informações devem ser trocadas utilizando o Bluetooth como via de
comunicação e o Java como linguagem de programação.
1.2 Estrutura do trabalho
O capítulo 2 – ASPECTOS TEÓRICOS – introduz as tecnologias Bluetooth e Java,
aqui empregadas. As definem e traz seus históricos. Também é descrita a arquitetura dos
dispositivos móveis e a forma como são classificados. Existe também uma breve descrição do
Sistema Operacional empregado e o porquê de seu uso.
O capítulo 3 – METODOLOGIA DE DESENVOLVIMENTO – descreve as
ferramentas para edição utilizadas, o sistema operacional usado e os Vendors-SDK que foram
instalados. Também traz toda a documentação do desenvolvimento dos aplicativos e mostra
os códigos comentados.
No capítulo 4 – RESULTADOS E DISCUSSÕES – é possível apreciar os testes
efetuados nos protótipos criados assim como breve discussão acerca do desenvolvimento dos
aplicativos.
O último capítulo – CONCLUSÕES – trata das conclusões sobre as ferramentas
utilizadas e dos resultados atingidos. Ficam também disponíveis algumas sugestões de
continuação desse trabalho.
3
2 ASPECTOS TEÓRICOS
Esse capítulo traz a contextualização das tecnologias utilizadas no desenvolvimento do
trabalho. Além de descrever a tecnologia Bluetooth e Java, também fala da utilização da API
Bluetooth Java, utilizada por todo o trabalho.
2.1 Dispositivos Móveis
Dispositivos móveis são equipamentos capazes de processar e armazenar dados assim
como computadores pessoais, mas se diferenciam desses pelo seu tamanho e capacidade de
mobilidade. Seu maior ícone é o celular está presente na vida de grande parte da população.
Pode ser ainda dividido quanto às características específicas dependendo da forma como é
analisado, como será visto no capítulo sobre a linguagem Java.
2.2 A Tecnologia Bluetooth
Bluetooth é uma tecnologia de comunicação por rádio de baixa freqüência e de alcance
entre 1 e 100 metros usado, principalmente, para interligar equipamentos eletrônicos e efetuar
troca de dados a pequenas distâncias. Foi inicialmente desenvolvida como uma nova forma de
conexão para dispositivos móveis e que aliasse baixo custo na integração com seus produtos e
um baixo consumo de energia. A baixa potência de seus transmissores, apesar de limitar a
distância pode aumentar a autonomia das baterias dos equipamentos portáteis (BRUCE &
GILSTER, 2002).
Originalmente criada pela empresa Ericsson®
e desenvolvida em conjunto com a
IBM®
, Intel®
, Nokia®
e Toshiba®
, a tecnologia propunha interligar telefones a outros
dispositivos, como PDAs e fones de ouvido de forma sem fio. Essas empresas formaram a
SIG, um consórcio que hoje conta com mais de 13 mil empresas (The Official Bluetooth
Technology info Site, 2010).
O nome Bluetooth foi dado em homenagem a Harald Blaatand (Bluetooth) II (940 –
981), rei viking que unificou a Dinamarca e a Noruega (BRUCE & GILSTER, 2002).
A idéia inicial era apenas interligar equipamentos sem a necessidade de cabos,
utilizando ondas de rádio e circuitos baratos que pudessem ser incorporados sem muito ônus.
Mas logo se tornou uma concorrente a redes WLans.
4
Em 1999 o consórcio Bluetooth emitiu um documento de 1500 páginas da versão 1.0
da nova tecnologia. Pouco depois, o IEEE, que também estudava a área de redes sem fio,
adotou a especificação do padrão Bluetooth e começou a alterá-la, a qual difere da
padronização criada pelo SIG principalmente no que diz respeito ao foco dos estudos. O
Bluetooth é um padrão completo, que vai desde a camada física até a camada de aplicação. O
IEEE se compromete a padronizar apenas as camadas física e de enlace (TANENBAUM, 2003).
O padrão Bluetooth formalizado pelo IEEE está descrito dentro da pilha 802.15 de protocolos
que formaliza as Pans. Isso não quer dizer que o SIG, como se conheceu, deixou de existir ou
enfraqueceu, mas o que se espera é que futuramente os dois venham a se juntar em um único
padrão.
2.2.1 Arquitetura Bluetooth
Uma rede Bluetooth se organiza conceitualmente por um nó mestre e até seis nós
escravos ativos. Esses nós ficam em uma distância de até 10 metros, porém dependendo da
potência da antena essa distância pode aumentar. Tal organização é denominada piconet.
Várias piconets podem coexistir dentro de um mesmo ambiente. Nesse caso, elas se
interligam por um nó de ponte. Várias piconets interligadas são denominadas uma scatternet
(TANENBAUM, 2003).
Mas uma piconet não se limita a sete membros conectados apenas. Podem fazer parte
da mesma piconet ainda 255 nós inativos. São ditos estacionados e ficam em estado de baixa
energia. Eles podem apenas responder a um sinal de ativação passado pelo nó mestre. Com
isso eles são ativados e tomam o lugar de algum outro nó ativo anteriormente
(TANENBAUM, 2003).
A seguinte imagem exibe duas piconets, A e B, formando uma scatternet:
Figura 1 - Scatternet formada por duas piconets
5
O motivo para que seja utilizada a arquitetura tipo mestre/escravo é que seus
arquitetos pretendiam disponibilizar circuitos Bluetooth por menos de cinco dólares
(TANENBAUM, 2003).
2.2.2 Pilhas de protocolos do Bluetooth
Como descrevem Hopkins e Antony (2003), a pilha de protocolos Bluetooth é o agente
de controle que atua sobre o dispositivo Bluetooth. Ela pode estar na forma de software,
firmware, hardware ou um misto dos três. A pilha de protocolos permite a comunicação com
outros dispositivos Bluetooth e também a comunicação com o próprio dispositivo. Os
protocolos se dividem entre camadas e perfis.
A seguir estão descritas as camadas e o modo que elas agem conforme descrito por
Hopkins e Antony (2003) e a Figura 2 exibe como elas estão organizadas:
A Interface de Controle do Nó (HCI) é a camada que entrega os dados
diretamente para o dispositivo Bluetooth. Por ela trafega tudo a ser recebido ou
enviado (voz e dados).
O Protocolo de Adaptação e Controle do Link, também chamado de L2CAP,
faz o empacotamento de segmentos de dados antes de serem enviados e
remonta os pacotes entrantes tal como um protocolo multiplexador. Se for
detectado um segmento de dados muito grande, esse protocolo quebra-o em
pedaços menores para o envio. Cuida apenas de dados, pois o áudio tem acesso
direto à camada HCI.
O Protocolo de Descoberta de Serviço (SDP) é usado para descobrir os
serviços que cada dispositivo Bluetooth oferece. Os serviços devem ser
publicados para que outros dispositivos o conheçam. Um bom exemplo de
serviço oferecido é dado por uma impressora. Ela oferece o serviço de
impressão de documentos. A descoberta de serviços será mais bem tratada em
capítulo posterior.
RFCOMM é uma porta de comunicação serial. Por ser Wireless é conhecida
como Porta de Comunicação por Rádio Freqüência e é capaz de simular uma
porta serial comum.
A camada de Especificação do Protocolo de Controle de Telefonia (TCS-BIN)
é usada para envio de sinais de controle ao dispositivo quando algum aplicativo
utiliza áudio, como uma chamada telefônica com uso de fones de ouvido sem
fio.
6
O Protocolo de Acesso sem Fio (WAP) é utilizado para conexão de internet.
Foi um protocolo adotado pelo SIG para suprir necessidades do Bluetooth e
requer que os protocolos PPP, IP e UDP estejam presentes.
OBEX é o protocolo usado para transferência de arquivos entre dispositivos
Bluetooth. Foi inicialmente desenvolvido para ser utilizado na comunicação
Infra-Vermelho e, assim como o Protocolo de Acesso sem Fio foi adotado para
ser utilizado no Bluetooth.
O Protocolo de Encapsulamento de Redes Bluetooth (BNEP) possibilita
transmitir outros protocolos de rede por meio do Bluetooth.
Finalmente, o Protocolo de Dispositivo de Interface Humana (HID) lista as
regras para transmissão de informações de dispositivos como teclados e mouse.
2.2.2.1 Perfis da Pilha de Protocolos Bluetooth
Normalmente, o arquiteto da aplicação utiliza a estrutura dos protocolos de rede e
tenta descobrir como utilizá-los para servir ao propósito de seu aplicativo. O protocolo em si
não dá pistas de como e para qual propósito deve ser utilizado. Diferentemente disso, o padrão
Bluetooth em sua versão 1.1 identificava 13 tipos de aplicações diferentes que poderiam ser
usadas pelos projetistas. Para se comunicar, os dispositivos deveriam implementar as mesmas
Figura 2 - Camadas do Protocolo Bluetooth
7
funcionalidades. Os chamados perfis, listados na tabela abaixo mostram bem quais eram as
idéias principais do consórcio Bluetooth.
Nome Descrição
Acesso genérico Procedimento de gerenciamento de enlaces
Descoberta de serviço Protocolo para descobrir serviços oferecidos
Porta serial Substitui um cabo de porta serial
Intercâmbio genérico de objetos Define o relacionamento cliente/servidor para movimentação de
objetos
Acesso de LAN Protocolo entre um computador móvel e uma LAN fixa
Rede dial-up Permite que um notebook se conecte através de um celular
Fax Permite que um equipamento de faz móvel se comunique com
um telefone móvel
Telefonia sem fio Conecta um aparelho telefônico à sua estação-base local
Intercomunicador Intercomunicação digital
Fone de ouvido Permite a comunicação de voz sem o uso das mãos
Push de objetos Fornece um meio para intercambiar objetos simples
Transferência de arquivos Fornece um recurso mais geral de transferência de arquivos
Sincronização Permite sincronizar um PDA com outro computador.
A base para todos os outros perfis está no perfil de acesso genérico e junto com o
perfil de descoberta de serviço, que tenta descobrir quais os serviços disponíveis em outros
aparelhos, forma a base do Bluetooth e todos os aparelhos devem utilizar, pelo menos, esses
dois perfis.
O perfil de porta serial é utilizado pela maioria dos outros perfis, pois programas que
já utilizem a comunicação por portas seriais podem facilmente migrar para a rede sem fio
Bluetooth. Interage diretamente com a camada RFCOMM.
2.3 JAVA
Java é uma linguagem de programação orientada a objetos que é compilada para um
código intermediário, o Bytecode, que é processado por uma máquina virtual no momento da
execução do programa. O Java tem como importante característica a não dependência da
Tabela 1 - Os perfis do Bluetooth
8
plataforma onde irá ser executada, desde que exista uma máquina virtual Java para essa
plataforma. Têm sido muito utilizada em dispositivos de comunicação móveis, aparelhos
receptores de sinal de TV digital, computadores e todo tipo de aparelhos que tenha um
microprocessador.
Em 1991, a Sun Microsystems®
financiou um projeto de pesquisa corporativa interna
com o codinome Green, que deu origem ao desenvolvimento de uma linguagem de
programação baseada em C++ batizada de Oak pelo seu criador James Gosling. Mais tarde,
foi descoberto que esse nome já era usado para outra linguagem e em uma cafeteria local o
nome Java (cidade de origem de um café importado) foi sugerido e aceito.
Inicialmente, o projeto Green previa uma linguagem de programação que rodasse em
tudo que pudesse ter um microprocessador. O projeto passava por dificuldades, pois o
mercado de equipamentos eletrônicos inteligentes, alvos da nova linguagem a ser
desenvolvida, não estava se desenvolvendo tão rapidamente como era previsto e havia o risco
do projeto ser cancelado. Nessa mesma época, a World Wide Web explodia e a Sun viu
possibilidade de utilizar o Java para criar conteúdo dinâmico para páginas Web. Isso deu nova
razão de existir ao Java(DEITEL, H.; DEITEL P., 2005).
Segundo Mary Campione e Kathy Walrath (2010) a linguagem de programação Java
tem as seguintes características:
Orientada a Objetos
Simples
Distribuída
Multithread
Dinâmica
Portátil
De Alto Desempenho
Robusta
Segura
Para ser executado, um código Java escrito recebe a extensão .Java. O código é então
compilado pelo compilador Javac. Um arquivo .class é criado e contém um código na
9
linguagem da Máquina Virtual chamado Bytecode. Ao ser executado uma nova instância da
Máquina Virtual é lançada e traduz o código em Bytecodes para a linguagem nativa do
sistema. É pela tradução do Byitecode em código nativo em tempo de execução que o arquivo
.class pode ser executado em qualquer sistema nativo que tenha uma Máquina Virtual Java
desenvolvida sem modificações (Mary Campione e Kathy Walrath, 2010).
A Figura 3 mostra o esquema de construção de um programa em Java:
JRE é um Kit que contém a máquina Virtual Java e bibliotecas utilizadas apenas para
executar uma aplicação Java.
A plataforma Java é composta da Máquina Virtual e das APIs. As APIs são conjuntos
de classes prontas para serem adicionadas ao projeto. APIs com características parecidas são
agrupadas em bibliotecas e recebem o nome de pacotes. A Figura 4 exibe a integração entre
máquina virtual e a API Java.
Conforme Jandl (2003) para escrever um programa Java são necessários um editor de
textos ASCII e um Kit de desenvolvimento Java (JDK).
Figura 3 - Processo de criação de um programa Java
Figura 4 - Plataforma Java
10
Ao invés de se usar um editor de texto comum, existe a opção de utilizar um IDE
(Ambiente de Desenvolvimento Integrado) para facilitar a digitação. O editor do IDE facilita
a digitação do código-fonte e agilizando o processo.
O Java Deveolpment Kit é composto por:
Um compilador para linguagem Java
Uma máquina virtual
Um programa para geração de documentação (Javadoc)
Um utilitário para criar arquivos compactados Java Archive (jar)
Uma extensa biblioteca de classes padronizadas Java
Um ambiente de execução Java
Os Kits de desenvolvimento mais utilizados atualmente são os oferecidos pela Sun
Microsystems e se dividem em:
Java SE – Java Standard Edition é utilizado para desenvolver a maioria dos
aplicativos. É o padrão para se começar a desenvolver em Java.
Java EE – Java Enterprise Edition inclui um servidor de aplicativos, um
servidor web, APIs específicas, suporte a Enterprise JavaBeans, Java Servlets
APIs e suporte a tecnologia Java Server Pages (JSP).
Java ME – Utilizada para escrever aplicativos para plataformas com menor
poder de processamento e memória, como é o caso de aplicativos para
celulares e Set-up Boxes.
Java FX – Java FX Script Technology é uma linguagem que possibilita o
desenvolvimento com alta produtividade de conteúdo para o ambiente Java.
Em seguida são descritos os Kits usados no desenvolvimento desse projeto.
2.3.1 Java Standard Edition
Java SE é composto das Bibliotecas necessárias para se executar um programa Java,
da máquina virtual Java e ferramentas para se escrever programas Java, como compiladores e
debugadores. É a base para desenvolver aplicativos Java e deve estar instalada mesmo que
outro Kit seja utilizado.
Como descrito no site da Oracle (2010), atualmente o Java SE se encontra na versão 6.
11
2.3.2 Java Micro Edition
Conforme Knudsen e Li (2005), Java ME é o Kit da plataforma Java da Oracle
utilizado para desenvolvimento de aplicativos para dispositivos de tamanho, processamento e
quantidade de memória reduzidos tais como celulares, smartphones, pagers e set-up boxes.
O Java ME divide os dispositivos em três categorias: Configuração, Perfis e APIs
opcionais.
A configuração dos aparelhos se baseia na capacidade de processamento e memória.
Há duas famílias de configuração: CDC e CLDC. Dispositivos classificados como
CDC tem no mínimo 512 KB de memória de acesso somente de leitura (ROM), 256 KB de
memória de acesso volátil (RAM), algum tipo de conexão de rede e devem aceitar uma versão
completa da JVM. São representados por aparelhos GPS e set-up Boxes.
CLDC são aparelhos como menor poder de processamento e memória. Devem ter um
mínimo de 160 KB de ROM
Os Perfis de dispositivos têm como base a configuração, mas classificam os
dispositivos quanto a características mais específicas como se o aparelho possui display, qual
seu método de armazenamento estático e quais os métodos de conexão, por exemplo. Além de
configuração e perfil, podem ser disponibilizadas APIs específicas para cada dispositivo.
A Figura abaixo mostra algumas das configurações e perfis mais comuns.
Figura 5 - Configurações e Perfis mais comuns
12
2.3.3 API Bluetooth Java
Como descrito por Ropkins e Antony (2003), para se tornar um padrão Java aceito
pela comunidade de desenvolvedores e empresas da área uma nova tecnologia deve passar por
alguns processos de testes e certificações a fim de garantir sua aplicabilidade e eficiência. A
JCP é uma comissão formada por empresas líderes do setor e por técnicos renomados que
criam regras e testes para padronizar a tecnologia recém criada. JSR é um documento que
contém as especificações dessa nova proposta de padronização. A JSR-82 faz parte da JCP
que trata da API Bluetooth e é liderada pela Motorola tendo ajuda de mais dezessete empresas
do setor e ainda auxílio individual de Peter Dawson, Steven Knudsen e Bread Threatt.
A comissão encarrega-se da criação de normas que norteiem a utilização da
tecnologia, a Implementação de Referência (RI) e de um Kit para desenvolvimento (TCK).
Qualquer empresa que se baseie na JSR pode utilizá-la para criar seu próprio Kit de
Desenvolvimento de Software (SDK). Existem muitas empresas que desenvolvem seu próprio
SDK Java para Bluetooth e algumas estão listadas abaixo e uma versão atualizada dessa lista
pode ser conseguida em www.JavaBluetooth.com.
Nome da
empresa
Suporte a API
Javax.Bluetooth
Suporte a API
Javax.obex
Plataformas Java
Suportadas
Sistemas Operacionais
Suportados
Atinav Sim Sim Java Micro Edition,
Java Standart Edition
Win-32, Linux, Pocket
PC
BlueCove Sim Sim Java Standart Edition Win-32, Mac OS X,
Linux, Pocket PC
Ericson Não Não Java Standart Edition Win-32, Linux
Esmertec Sim Não Java Micro Edition Win-32, Palm OS,
Pocket PC, outros
Harald Não Não Java Standart Edition Win-32, Linux, outros
Possio Sim Sim Java Micro Edition Win-32, Linux
Rococo Sim Sim Java Micro Edition,
Java Standart Edition
Win-32, Linux, Palm
OS, Pocket PC
Smart Network
Device
Sim Não Java Micro Edition HyNetOS
SuperWaba Não Não Waba JVM PalmOS
Zucotto Não Não Java Micro Edition,
Java Standart Edition
Win-32
Tabela 2 - Kits de Desenvolvimento e suas Empresas
13
Fazem parte dos aplicativos Java Bluetooth os seguintes componentes (Ropkins e
Antony, 2003):
Pilha de Inicialização
Gerenciamento do dispositivo
Descoberta de dispositivos
Descoberta de Serviços
Registro de Serviços
Comunicação
A Central de Controle Bluetooth (BCC) define algumas configurações de segurança
para o dispositivo Bluetooth. Más, apesar de estar presente na JSR-82 como sendo um item a
ser implementado, não define como isso deve ser feito. Isso leva os fabricantes a construírem
cada um seu próprio BCC, seja usando Java, seja usando uma linguagem nativa como C ou
C++. Além disso, as funcionalidades definidas para cada BCC também podem variar.
Algumas funcionalidades descritas na JSR-82 são:
Configurações básicas de segurança
Mantém lista dos dispositivos já pareados (o dispositivo não precisa estar
pareado naquele instante)
Mantém lista dos dispositivos considerados seguros
Contem mecanismo para pareamento de dispositivos
Contem mecanismo para autorizar requisições de conexão
Suas configurações não devem ser modificadas a não ser por ele mesmo
2.3.3.1 Pilha de Inicialização
Para preparar o dispositivo para operar, a pilha de protocolos deve ser inicializada. A
pilha é a última camada de contato com o hardware do dispositivo e o habilita para transferir
os dados. Para isso é utilizada uma seqüência de comandos que podem variar em relação ao
Kit de desenvolvimento utilizado. Alguns Kits já configuram a pilha de uma maneira padrão e
não necessitam que o programador o faça.
14
2.3.3.2 Gerência do Dispositivo
Continuando com a descrição da API Java Bluetooth feita por Ropkins e Antony
(2003) e baseando-se na API Java Standart edition, para se obter informações a respeito do
dispositivo utilizado e dos dispositivos pareados foram criadas as classes LocalDevice e
RemoteDevice. Essas classes fazem parte do Perfil de Acesso Genérico e é a partir delas que
é obtido acesso às configurações dos dispositivos. A classe DeviceClass é utilizada para obter
informações sobre como é classificada a configuração que o dispositivo próximos tem, como
smartphones, celulares, computadores, pontos de acesso, etc.
Classe Javax.Bluetooth.LocalDevice:
Essa classe é usada para se obter informações e manipular o dispositivo Bluetooth em
uso. Só é possível ter uma instância dela por Máquina Virtual (JVM) já que para cada
dispositivo Bluetooth em funcionamento é lançada uma instância da JVM.
Para se instanciar um objeto apto a obter as informações do dispositivo é usado o
método static getLocalDevice():
LocalDevice localdevice = LocalDevice.getLocalDevice().
Esse método pode lançar uma exceção do tipo BluetoothStateException se o
dispositivo não estiver funcionando corretamente.
public String localDevice.getBluetoothAddress():
O método getBluetoothAddress() devolve o endereço Bluetooth do dispositivo. Esse
endereço é constituído por uma string de 12 caracteres de números hexadecimais.
public boolean localDevice.setDiscoverable(int modo):
Habilita a opção de ficar visível para os outros dispositivos Bluetooth.
A tabela 3 exibe as opções para modo disponíveis:
15
Modo de
Acesso
Nome Completo Descrição Valor
Inteiro
Valor
Hexadecimal
NOT_DISCO
VERABLE
Invisível Não permite que outros
dispositivos o detecte
0 0
GIAC Código de acesso a
pesquisa geral ou ilimitada
Permite deixar o
dispositivo visível
10390323 0x9E8B00
LIAC Código de acesso a
pesquisa limitada
Permite deixar o
dispositivo visível pelo
tempo de 1 minuto
10390272 0x9E8B33
public int localDevice.getDiscoverable():
Retorna os estado de visibilidade atual do dispositivo. As constantes
NOT_DISCOVERABLE, GIAC OU LIAC são retornadas em forma de números inteiros.
Classe Javax.Bluetooth.RemoteDevice:
Oferece acesso a um único dispositivo que esteja próximo.
public final String getBluetoothAddress():
Esse método retorna o endereço do dispositivo.
public String getFriendlyName(boolean alwaysAsk):
Devolve um nome amigável do dispositivo remoto questionado.
Classe Javax.Bluetooth.DeviceClass:
Essa classe possui dois métodos usados para descobrir a qual classe o dispositivo
questionado faz parte. Os métodos public int getMinorDeviceClass() e public int
Tabela 3 - Modos de visibilidade do dispositivo Bluetooth
16
getMajorDeviceClass() retornam um número inteiro que pode ser usado para descobrir a
classe de dispositivos. A tabela 4 relaciona algumas dessas classes.
Classe Maior Classe Menor Descrição da Classe Maior Descrição da Classe Menor
256 4 Computer Desktop
256 12 Computer Notebook
256 20 Computer PDA
512 4 Celular Celular
512 12 Celular Smartphone
1024 8 Dispositivo de Audio Fone de ouvido
1280 64 Periféricos de Computador Teclado
1280 128 Periféricos de Computador Mouse
1536 32 Dispositivo de Imagem Câmera
1536 128 Dispositivo de Imagem Impressora
2.3.3.3 Descoberta de Dispositivos
Classe Javax.Bluetooth.DiscoveryAgent:
Essa classe é utilizada para descobrir os dispositivos que estão disponíveis ao redor.
O objeto localDevice instanciado para obter as propriedades do dispositivo local é
utilizado também para instanciar um objeto que fará a busca por outros dispositivos:
LocalDevice localDevice = LocalDevice.getLocalDevice()
DiscoveryAgent discoveryAgent = localDevice.getDiscoveryAgent()
Essa classe possui dois métodos para efetuar a busca por dispositivos:
public boolean startInquiry(int codAcesso, DiscoveryListener listener):
Com esse método é possível iniciar uma pesquisa por dispositivos próximos. O
codAcesso pode ser uma das três constantes: NOT_DISCOVERABLE, LIAC ou GIAC. Um
objeto de uma classe que implementa a interface DiscoveryListener deve ser passado como
Tabela 4 - Classes de dispositivos Bluetooth
17
segundo parâmetro. Eventos são repassados a esse objeto à medida que novos dispositivos são
encontrados.
public RemoteDevice[] retrieveDevice(int opcao):
Retorna uma lista de objetos do tipo RemoteDevice que possam ter sido encontrados
pelo método startInquiry(). A variável opcao pode conter as constantes CACHED (0) ou
PREKNOWN (1). CACHED pode ser um dispositivo encontrado em uma pesquisa recente,
enquanto que PREKNOWN pode ser um dispositivo freqüentemente acessado.
Interface Javax.Bluetooth.DiscoveryListener:
Essa interface deve estar implementada na classe principal do aplicativo para que essa
classe seja avisada quando um novo dispositivo for encontrado.
public void deviceDiscovered(RemoteDevice btDevice, DeviceClass code):
Esse método é chamado pela máquina virtual quando o método startInquiry() retorna
um dispositivo encontrado. O RemoteDevice é uma referência ao dispositivo encontrado,
enquanto que DeviceClass é o tipo de dispositivo encontrado referente a tabela 4.
2.3.3.4 Descoberta de Serviços
Com as instruções acima é possível instanciar o próprio dispositivo, procurar por
dispositivos novos e instanciar os novos dispositivos. Mas para que seja possível executar
alguma ação útil é necessário saber quais os tipos de serviço que cada dispositivo encontrado
pode oferecer. Como exemplo, uma impressora encontrada tem o serviço de impressão
registrado no seu SDDB. SDDB é um banco de dados de pequeno porte usado para armazenar
os serviços de cada dispositivo.
Outra forma de encontrar o serviço disponibilizado por um dispositivo é consultar a
classe de dispositivos da qual ele faz parte. Mas o serviço registrado no SDDB é mais
específico do que os baseados apenas na classe de dispositivo, portanto mais utilizado.
No SDDB ficam armazenados os registros dos serviços que cada dispositivo pode
executar na forma de um ServiceRecord.
18
Entradas em um ServiceRecord são chamadas de atributos e contêm um ID e um valor
a ele atribuídos.
Os valores dos atributos chamados DataElements podem ser do tipo int, boolean,
UUID ou uma enumeração.
Classe Javax.Bluetooth.UUID:
A classe UUID identifica os serviços possíveis da pilha de protocolos Bluetooth. Como
exemplo, para enviar um arquivo por meio do perfil de entrega de objetos OBEX, deve-se
efetuar a descoberta de serviços utilizando o UUID 0x1105 que é o UUID do OBEX. Abaixo a
tabela 7 mostra os UUID de cada protocolo e a tabela 8 exibe alguns dos perfis mais
utilizados. Utilizar um UUID de um protocolo ou de um perfil define a especificidade da ação
desejada. Cabe lembrar que um perfil é sempre baseado em um protocolo Bluetooth e por isso
é apenas mais específico em relação à ação a executar, mas continua usando o protocolo base.
Figura 6 - SDDB e dois Registros de Serviços suportados
Figura 7 - Atributos em um ServiceRecord
19
Protocolo UUID (Decimal) UUID (Hexadecimal)
SDP 1 0x0001
RFCOMM 3 0x0003
L2CAP 256 0x0100
HTTP 12 0x000C
FTP 10 0x000A
TCP 4 0x0004
IP 9 0x0009
UDP 2 0x0002
BNEP 15 0x000F
OBEX 8 0x0008
TCS-BIN 5 0x0005
Perfil Nome do
Serviço
UUID
(decimal)
UUID
(Hexadecimal)
Porta Serial Porta Serial 4353 0x1101
Transferência
de Objetos
OBEX 4357 0x1105
Acesso
Genérico
HeadSet 4360 0x1108
Impressora
Básica
Impressão 4386 0x1122
Dispositivos
de Interface
Humana
Mouse,
Teclado
Bluetooth
4389 0x1125
Rede Genérica n/a 4609 0x1201
public UUID(long uuidValue):
Esse é o método construtor da classe UUID. Ele simplesmente depende de um valor
do tipo long.
public UUID(String uuidValue, boolean shortUUID):
Já esse método permite construir um UUID apartir de uma String. Se shortUUID
estiver setado como verdadeiro, o valor de retorno terá 16 bits ao invés de 128 como o
normal. Não deve ser inserido o 0x de hexadecimal para se utilizar esse método.
Tabela 5 - UUID referentes aos protocolos Bluetooth
Tabela 6 - UUID referentes aos Perfis Bluetooth
20
Javax.Bluetooth.DiscoveryAgent:
Essa classe, já utilizada para prover a descoberta de dispositivos, também é usada para
a descoberta de serviços. Os dois métodos seguintes são utilizados para descobrir os serviços
disponíveis em dispositivos remotos.
public int searchServices(int[] attrSet, UUID[] uuidSet, RemoteDevice btDev,
DiscoveryListener discListener):
Com esse método é possível procurar por uma lista de serviços disponíveis em um
único dispositivo por vez. O parâmetro uuidSet do tipo UUID[] é uma lista dos serviços que
se procura no dispositivo e já dever ter sido criada. Quando o dispositivo remoto sinaliza
possuir um dos serviços relacionados na lista de serviços procurados a lista attrSet é
preenchida com os atributos relacionados aos serviços que batem. O objeto btDev da classe
RemoteDevice é uma referência ao dispositivo pesquisado. Também deve ser implementado
um objeto que seja a interface da classe DiscoveryListener para que seja possível receber
chamadas de eventos quando um serviço relacionado for encontrado.
public String selectService(UUID uuid, int security, boolean master):
Esse método é usado para procurar por um serviço específico em qualquer dispositivo
disponível. Se houver algum serviço encontrado que bata com os solicitados, esse método
retorna uma String que deve ser usada por Conector.open() que cria uma conexão com o
dispositivo.
Interface Javax.Bluetooth.DiscoveryListener:
Essa interface também é utilizada para instanciar um objeto para fazer a busca por
serviços e seus métodos principais são:
public void serviceDiscovered(int transID, ServiceRecord[] servRecord):
Esse é um método chamado pela JVM quando serviços procurados são encontrados no
dispositivo remoto e o método DiscoveryAgent.searchServices() implementar a interface
21
DiscoveryListener. Com esse método pode-se obter um identificador da transação e uma lista
do tipo ServiceRecord com os serviços oferecidos pelo dispositivo remoto. Com um
ServiceRecord é possível conectar ao dispositivo e fazer uso desse serviço.
Classe Java.Bluetooth.ServiceRecord:
Essa é a classe usada para instanciar um objeto do tipo ServiceRecord que é usado
como entrada na tabela SDDB e que especifica os serviços oferecidos pelo dispositivo.
Classe Java.Bluetooth.DataElement:
Cada ServiceRecord é formado por um conjunto de atributos da classe DataElement.
Um DataElement pode ser formado apartir dos sequintes tipos:
Inteiros
Booleanos
Strings
UUIDs
Seqüência dos tipos acima
2.3.3.5 Registro de Serviços
Para um dispositivo servidor poder oferecer um serviço, esse serviço deve antes ser
publicado para, então, poder ser visto pelos clientes. Esse processo recebe o nome de Registro
de Serviços.
Para que um serviço seja publicado no SDDB é necessário usar o método estático
Connector.open() e fazer um cast com a classe StreamConnectionNotifier. O objeto
StreamConnectionNotifier é passado para o método getRecord() da classe LocalDevice é
então é obtido um objeto do tipo ServiceRecord. Para que o serviço possa ser visto pelos
dispositivos Bluetooth, o método acceptAndOpen() da classe StreamConnectionNotifier é
chamado e fica a espera dos dispositivos remotos. Quando o processo termina, é utilizado o
método close() da classe StreamConnectionNotifier para encerrá-lo.
22
// criando os objetos utilizados
streamconnectionnotifier notifier = null;
streamconnection sconn = null;
localdevice localdevice = null;
servicerecord servicerecord = null;
// abrindo a conexão
// a string url já deve ter sido criada
notifier = (streamconnectionnotifier)connector.open(url);
// instanciar o objeto localdevice e obtendo o servicerecord
localdevice = localdevice.getlocaldevice();
servicerecord = localdevice.getrecord(notifier);
// esse método bloqueia a thread até que algum dispositivo responda
notifier.acceptandopen();
//o serviços está registrado no sddb
//esperar uma conexão.Quando o cliente terminar
notifier.close()
2.3.3.6 Comunicação
Existem três modos para que dois dispositivos possam se comunicar. Os mais comuns
são o protocolo RFCOMM e o protocolo L2CAP.
O protocolo RFCOMM é o mais usado. É fácil adaptá-lo em aplicativos que fazem uso
da porta serial para comunicação via Bluetooth. Por utilizar comunicação serial na
transmissão de dados é o mais indicado quando é necessário fazer troca de dados de modo
contínuo, como por exemplo, transmissão de imagem.
Em uma comunicação usando o RFCOMM existe o conceito de seção e conexão. Uma
seção é iniciada entre dois dispositivos comunicantes e podem ter uma ou mais conexões para
realizar uma tarefa completa. Múltiplas seções só podem ocorrer com dispositivos diferentes.
23
Um dispositivo que vai agir como um servidor precisa basicamente usar o mesmo
código do registro de serviços. A String url precisa ser iniciada com “btspp://localhost:”
seguida de um número de 256 ou 128 bits no formato hexadecimal. Esse número precisa ser
diferente de outro encontrado em outro dispositivo. Opcionalmente, é possível nomear esse
serviço que está sendo criado com o seguinte comando: “name=serialconn” separado por um
“;” do resto da URL, em que serialconn é o nome do ServiceRecord.
// criando os objetos utilizados
StreamConnectionNotifier notifier = null;
StreamConnection con = null;
LocalDevice localdevice = null;
ServiceRecord servicerecord = null;
InputStream input;
OutputStream output;
//criando a URL que contém o UUID com pequena chance de conflito
String url = "btspp://localhost:00112233445566778899AABBCCDDEEFF;
name=serialconn";
// abrindo a conexão e efetuando um cast para StreamConnectionNotifier
notifier = (StreamConnectionNotifier)Connector.open(url);
//bloqueando a thread até um acesso de um cliente
con = notifier.acceptAndOpen();
// se houver resposta de algum cliente abrir os streams de dados
input = con.openInputStream();
output = con.openOutputStream();
// agora é possível enviar e receber dados pelos streams
Para estabelecer uma conexão para o cliente recupera-se a URL com o método
getConnectionURL() da classe ServiceRecord e abre a conexão com o método estático
Connector.open() passando a url como seu parâmetro.
String connectionURL = serviceRecord.getConnectionURL(0, false);
StreamConnection con = (StreamConnection)Connector.open(connectionURL);
24
Para as conexões utilizando o protocolo L2CAP é necessário entender o conceito de MTU
(Unidade Máxima de Transmissão). L2CAP utiliza a transmissão de dados em forma de pacotes.
O tamanho máximo que esses pacotes podem assumir deve ser negociado entre os dois
dispositivos comunicantes e recebe o nome de MTU. O padrão é utilizar 672 bytes por pacote.
Para encontrar o MTU possível para o dispositivo local é utilizado o seguinte método:
LocalDevice local = LocalDevice.getLocalDevice();
String receiveMTUmax = local.getProperty("Bluetooth.l2cap.receiveMTU.max");
Para abrir uma conexão também são usados os métodos Connector.open() e
acceptAndOpen() porém agora são usadas as classe L2CAPConnectionNotifier e
L2CAPConnection.
L2CAPConnectionNotifier notifier = (L2CAPConnectionNotifier).Connector.open(url);
L2CAPConnection con = (L2CAPConnection)notifier.acceptAndOpen();
E esse é o código para conexão do cliente:
L2CAPConnection = (L2CAPConnection)Connector.open(url);
2.4 Linux
GNU/Linux, ou simplesmente Linux como é mais conhecido é um composto de
softwares baseados na GPL que tem como kernel o Linux que formam um sistema
operacional de ambiente moderno seguro e estável para desktops, servidores e sistemas
embarcados. Trata-se de uma plataforma livre escrita por desenvolvedores ao redor do mundo
e que pode ser usada e modificada por todos os interessados, desde que sigam as leis da GPL
para isso.
25
3 METODOLOGIA DE DESENVOLVIMENTO
Esse capítulo oferece uma visão da seqüência de desenvolvimento do projeto e as
ferramentas utilizadas, inclusive para que possa ser recriado o ambiente de desenvolvimento
adotado.
3.1 Ferramentas Utilizadas
Para desenvolvimento desse trabalho foi utilizado como Sistema Operacional a
distribuição GNU/Linux Ubuntu versão 10.04 e que foi atualizado para 10.10 assim que essa
ficou disponível em outubro de 2010.
Foi instalado na máquina um dongle Bluetooth (antena Bluetooth) genérico facilmente
encontrado nas lojas de informática. Esse dispositivo promete ter o alcance de no máximo 10
metros. A foto do dispositivo Bluetooth adquirido para o projeto pode ser vista na Figura 8. O
Sistema Operacional instalou automaticamente os drivers para o novo dispositivo.
O Java instalado na máquina ao final do trabalho era a versão 6 update 22.
O banco de dados escolhido foi o MySQL Community Server versão 5.1.53 pois
também é fornecido sob a licença GPL.
O IDE utilizado para desenvolvimento desse aplicativo foi o NetBeans 6.9.1. O plugin
para Java Micro Edition também foi instalado pelo instalador do próprio IDE.
Para o desenvolvimento na plataforma Micro Edition também é necessário ter
instalado um emulador para JME. No caso o Kit Emulador utilizado foi o Sun Java Wireless
Toolkit da Oracle® na versão 2.5.2 para CLDC e que pode ser conseguido no site da Oracle
®.
Figura 8 - Dongle Bluetooth
26
O Kit de desenvolvimento para a API Bluetooth a ser usado no desenvolvimento de
aplicativos Java Standart Edition escolhido foi o BlueCove versão 2.1.0 por se tratar de um
Kit que pode ser utilizado no sistema operacional Linux, além de ser gratuito. Para utilizar o
BlueCove é necessário ter instalado o módulo que dá suporte ao BlueCove no Linux chamado
BlueZ versão 4.80. Informações sobre o BlueCove e sobre o BlueZ podem ser conseguidas no
site do projeto: bluecove.org.
Para teste do aplicativo cliente foi utilizado o celular Nokia®
5530 com o sistema
operacional Symbian S60 5.0.
3.2 Modelagem do Sistema
O projeto almeja a construção de dois aplicativos, um cliente e um servidor. O cliente
deve ser instalado em um dispositivo móvel como um celular ou smartphone. O aplicativo
servidor deve ser instalado em um computador desktop.
3.2.1 Descrição do Sistema
Para que fique mais claro o que se pretende com a construção desse projeto, optou-se
pela modelagem do sistema, a fim de facilitar o entendimento pelos leitores.
O servidor da aplicação se constitui por uma interface gráfica, onde o administrador do
sistema pode inserir os dados e um processo servidor que fica rodando em segundo plano
recebendo as requisições dos clientes. Os dados a serem inseridos são, no caso de produtos a
venda: o nome do produto, preço e localização, por exemplo, e no caso de um campanha
publicitária, o título e uma mensagem a ser enviada para os clientes, assim como, a data de
início e fim que aquela campanha deve ser veiculada.
O processo servidor fica pronto a espera de uma requisição dos usuários. Ao receber
uma requisição com o nome de um produto, por exemplo, o servidor pesquisa no banco de
dados as características do produto e devolve para o cliente uma tabela com o nome daquele
produto, sua marca, disponibilidade, localização, preço e produtos similares que possam
interessar ao cliente. Esse processo servidor também consulta o ambiente de tempos em
tempos para descobrir novos dispositivos passíveis de receberem o objeto da campanha, quer
seja uma nota de texto, imagem ou outro objeto que se pretenda enviar.
Os dispositivos clientes também têm a função de cliente e servidor, uma vez que se
comportam como clientes quando geram uma requisição de pesquisa ao servidor da aplicação,
27
e como servidor uma vez que estão ativos prontos a responderem a uma solicitação de
conexão do servidor da aplicação.
As pessoas habilitadas para interagir com o sistema são, portanto, o administrador do
sistema, ao qual caberá a tarefa de inserir os dados de produtos e campanha no sistema e os
clientes que devem ter o aplicativo cliente instalado em um celular ou smartphone e, apartir
dele, efetuar pesquisas e receber os resultados e campanhas publicitárias.Funcionalidades e
Diagramas de Casos de Uso
A Figura 9 traz as funcionalidades do sistema e traduz o exposto anteriormente:
Funcionalidades do ator administrador:
Casos de uso do ator administrador:
Funcionalidade Nome da Funcionalidade Caso de Uso
1 Cadastra Campanha Cadastrar Campanha()
Consultar Campanha()
Alterar Campanha()
Excluir Campanha()
2 Cadastra Produto Cadastrar Produto()
Consultar Produto()
Alterar Produto()
Excluir Produto()
Figura 9 - Visão geral das funcionalidades dos atores
Figura 10 - Funcionalidades do ator administrador
Tabela 7 - Casos de uso do ator administrador
28
Funcionalidades do ator usuário:
Casos de uso do ator usuário
Funcionalidade Nome da Funcionalidade Caso de Uso
1 Ler Campanha Consultar Campanha()
2 Pesquisa Produto Pesquisar Produto()
Consultar Produto()
3.2.2 Diagramas de Seqüência
As Figuras 12 e 13 apresentam os diagramas de seqüência de algumas das ações mais
importantes efetuadas pelos atores:
Figura 11 - Funcionalidades do ator usuário
Tabela 8 - Casos de uso do ator usuário
Figura 12 - Diagrama de seqüência de consulta de produtos
29
3.2.3 Diagramas de Classes
As Figuras 14 e 15 exibem as classes utilizadas para codificar o aplicativo servidor e o
aplicativo cliente:
Figura 13 - Diagrama de seqüência para enviar uma campanha
Figura 14 - Diagrama de classes aplicativo cliente
30
3.2.4 Protótipo das Telas do Aplicativo Servidor
A interface do protótipo do aplicativo se resume a três telas quem contêm as seguinte
funcionalidades:
login – para obter acesso ao sistema;
Principal – onde o administrador pode inserir e modificar as campanhas e conFigurar
os dias que estarão disponíveis;
Produtos – onde se tem acesso às atividades relacionadas aos produtos, como inserir
e editar os produtos.
Figura 15 - Diagrama de classes do aplicativo servidor
31
Figura 16 - Tela de login
Figura 17 - Tela Principal
32
3.2.5 Estruturação das Bases de Dados
A estrutura das bases de dados utilizadas é a seguinte:
Figura 18 - Tela de produtos
Tabela 9 - Estrutura Base de Dados
33
3.3 Codificação do Aplicativo Cliente
O sistema Cliente começou a ser codificado pela parte gráfica.
Em JME, para se exibir objetos na tela é necessário instanciar um objeto do tipo
Display e passar um objeto do tipo Displayable para ele. O objeto utilizado no aplicativo foi
um Form, que é um objeto que pode receber uma maior quantidade de itens a serem exibidos.
Outro objeto do tipo Displayable poderia ser um TextBox ou um objeto do tipo Scream
utilizado para construir interfaces de jogos. O objeto Displayable depois de instanciado deve
ser setado como corrente, isto é, ele que deve ser exibido na tela, no método startApp() da
classe.
public class Cliente extends MIDlet implements CommandListener {
private Display display = null;
private Form formPesquisa = null;
public Cliente() {
display = Display.getDisplay(this);
formPesquisa = new Form("Pesquisa");
}
protected void startApp() throws MIDletStateChangeException {
display.setCurrent(formPesquisa);
}
}
No construtor da classe, além de instanciar o objeto Display e o Displayable deve-se
construir todos os objetos que vão ser exibidos.
Usando o emulador do Wireless Toolkit da Oracle a apresentação do aplicativo ficou
como pode-se ver na Figura 19:
34
Figura 19 - Aplicativo Cliente
35
A Figura 20 exibe mais algumas telas do aplicativo:
Figura 20 - Telas diversas do aplicativo
36
3.4 Codificação do Aplicativo Servidor
Para o servidor, inicialmente foi feito a codificação da descoberta de dispositivos e
serviços usando o Bluetooth.
O código escrito até o momento é capaz de fazer a busca por dispositivos Bluetooth
próximos e reconhecer sua classe, seu endereço e seu nome, e pesquisar os serviços
disponíveis.
A Figura 21 e 22 exibem a pesquisa de novos dispositivos.
Figura 21 - Procura de dispositivos
37
Apesar de ambos os sistemas, Cliente e Servidor, não terem obtido êxito na sua
finalização os problemas a serem sanados demandam apenas tempo e prática na aplicação da
linguagem Java podendo ser finalizados ainda.
Figura 22 - Dispositivo encontrado
38
4 RESULTADOS E DISCUSSÕES
Finalizado o conjunto Cliente/Servidor devem trabalha da forma como mostrado pela
Figura 23 e 24:
Para distribuir uma campanha publicitária aos clientes de uma loja, como um
supermercado, o servidor, depois de efetuar pesquisa no banco para receber a campanha
disponível, começa a procurar por dispositivos próximos que tenham o aplicativo cliente
instalado e possam trocar informações. Ao encontrar um cliente o servidor envia a
mensagem para o usuário, que pode lê-la direto no seu celular.
O inverso acontece quando um usuário, ao entrar em uma loja com o servidor
instalado, digita no campo de pesquisa, o nome de um produto, como, por exemplo, café. O
aplicativo envia uma mensagem ao servidor, que por sua vez se comunica com o banco e
solicita o resultado da pesquisa. Ao receber o resultado o servidor envia os dados para o
usuário que pode ler o resultado da pesquisa no celular.
O resultado da pesquisa contém informações como nome e marca do produto, preço e
sua disponibilidade em estoque, além de sua localização dentro da loja:
Figura 23 - Envio de uma mensagem publicitária ao usuário
39
Figura 24 - Envio de uma solicitação de pesquisa ao servidor
40
5 CONCLUSÕES
Esse trabalho mostrou todo o procedimento para que uma aplicação faça uso de
dispositivos Bluetooth tanto para JME quanto para JSE visto que as mudanças nas duas
plataformas são ínfimas, já que a API Bluetooth para JSE foi totalmente baseada na API
Bluetooth JME e sua utilização é possível graças a Kits de desenvolvimento como o
BlueCove utilizado nesse projeto.
É possível encontrar muito material para desenvolvimento de aplicativos para JME
más o mesmo ainda não pode ser dito para a plataforma JSE. Esse cenário não poderia ser
diferente visto a intenção na concepção da tecnologia.
O trabalho, então, atinge seus objetivos ao compilar e mostrar o que é necessário para
se programar utilizando a API Bluetooth do Java inclusive utilizando um sistema operacional
livre, como é o caso do Ubuntu, utilizado nesse trabalho.
A finalização dos códigos e a transposição das dificuldades encontradas até aqui só
demandam mais tempo para serem superadas e esse se mostra um desafio e uma certeza que o
autor desse trabalho pretende perseguir.
5.1 Sugestões de Trabalhos Futuros
A finalização do código e teste efetuados em relação à distância de alcance das antenas
Bluetooth, e principalmente a aplicabilidade do sistema comercialmente já podem ser
encaradas como uma ótima continuação.
Nesse trabalho não se pensou em uma forma mais atrativa de exibir as mensagens
publicitárias para os clientes. Foi utilizado apenas texto para exibir as mensagens. Visto que é
possível se transferir qualquer tido de dado usando o Bluetooth, uma outra sugestão de
trabalho futuro seria a utilização de uma linguagem de marcação de texto como HTML para a
melhor visualização das mensagens de campanha.
41
6 REFERÊNCIAS BIBLIOGRÁFICAS
BRUCE, Walter R.; GILSTER, Ron. Wireless LANs: End to EndTM
. New York: Hungry
Minds, 2002.
CAMPIONE, Mary; WALRATH, Kathy. ABOUT THE JAVA TECHNOLOGY. Out.
2010. Disponível em: <http://download.oracle.com/Javase/tutorial/getStarted/intro/
definition.html>. Acesso em: 11 out. 2010.
DEITEL, Harvey M.; DEITEL Paul J. JAVA COMO PROGRAMAR. 6ª Edição. São Paulo:
Pearson Prentice Hall, 2005.
FANTÁSTICO. Faça o teste e veja se você é viciado em celular. Mar. 2010. Disponível
em: <http://fantastico.globo.com/Jornalismo/FANT/0,,MUL1548459-15605,00FACA+O+
TESTE+E+VEJA+SE+VOCE+E+VICIADO+EM+CELULAR.html>. Acesso em: 11 out.
2010.
HOPKINS, Bruce; ANTONY, Ranjith. BLUETOOTH FOR JAVA. New York: Apress,
2003.
INFO: Brasil tem mais celulares do que pessoas. Nov. 2010. Disponível em:
<http://info.abril.com.br/noticias/tecnologia-pessoal/brasil-tem-masi-celulares-do-que-pessoas
-20112010-3.shl>. Acesso em: 25 nov. 2010.
JANDL JUNIOR, Peter. INTRODUÇÃO AO JAVA. São Paulo: Berkley, 2002.
ORACLE. JAVA SE NAMING AND VERSIONS. Out 2010. Disponível em:<http://
www.oracle.com/technetwork/Java/Javase/namechange-140185.html>. Acesso em 13 out. 2010.
KNUDSEN, Jonathan; LI, Sing. BEGNNING J2ME: From Novice to Professional. 3ª
Edição. New York: Apress, 2005.
TANENBAUM, Andrew S. REDES DE COMPUTADORES. 4ª Edição. Rio de Janeiro:
Elsevier, 2003.
42
THE OFFICIAL BLUETOOTH TECHNOLOGY INFO SITE. About the Bluetooth SIG.
Out. 2010. Disponível em: <http://www.Bluetooth.com/English/SIG/Pages/default. aspx>.
Acesso em: 11 out. 2010.
