Escolar Documentos
Profissional Documentos
Cultura Documentos
ENGENHARIA DE COMPUTAÇÃO
NATAL
NOVEMBRO DE 2005.
UNIVERSIDADE POTIGUAR
ENGENHARIA DE COMPUTAÇÃO
NATAL
NOVEMBRO DE 2005.
ii
ÍNDICE
iii
3.2.5 Ambiente de desenvolvimento. ........................................................................................................ 44
3.3 PAREANDO DISPOSITIVOS BLUETOOTH ............................................................................................... 54
3.4 INSTALANDO APLICATIVOS NO CELULAR ............................................................................................ 67
3.4.1 API MIDIP - Fundamentos .............................................................................................................. 71
CAPÍTULO 4 – IMPLEMENTAÇÃO .................................................................................................. 77
4.1 CHATOOTH .......................................................................................................................................... 77
4.2 PC-PC .................................................................................................................................................. 79
4.2.1 Recursos ........................................................................................................................................... 80
4.2.2 A conexão......................................................................................................................................... 80
4.2.3 O Chat .............................................................................................................................................. 81
4.3 PC-CELULAR ....................................................................................................................................... 83
4.3.1 Definições Iniciais ............................................................................................................................ 83
4.3.2 Funcionamento ................................................................................................................................. 84
CAPÍTULO 5 – CONCLUSÃO ............................................................................................................. 90
ANEXO 1 ..................................................................................................................................................... 92
ANEXO 2 ..................................................................................................................................................... 93
ANEXO 3 ..................................................................................................................................................... 95
ANEXO 4 ................................................................................................................................................... 100
ANEXO 5 ................................................................................................................................................... 102
ANEXO 6 ................................................................................................................................................... 103
ANEXO 7 ................................................................................................................................................... 104
ANEXO 8 ................................................................................................................................................... 105
ANEXO 9 ................................................................................................................................................... 108
ANEXO 10 ................................................................................................................................................. 110
ANEXO 11 ................................................................................................................................................. 112
ANEXO 12 ................................................................................................................................................. 117
ANEXO 13 ................................................................................................................................................. 118
ANEXO 14 ................................................................................................................................................. 120
ANEXO 15 ................................................................................................................................................. 121
ANEXO 16 ................................................................................................................................................. 122
ANEXO 17 ................................................................................................................................................. 125
ANEXO 17 ................................................................................................................................................. 125
ANEXO 18 ................................................................................................................................................. 126
ANEXO 19 ................................................................................................................................................. 128
ANEXO 19 ................................................................................................................................................. 128
ANEXO 20 ................................................................................................................................................. 129
iv
ANEXO 21 ................................................................................................................................................. 135
ANEXO 22 ................................................................................................................................................. 137
ANEXO 23 ................................................................................................................................................. 138
ANEXO 24 ................................................................................................................................................. 140
ANEXO 25 ................................................................................................................................................. 142
v
LISTA DE FIGURAS
vii
LISTA DE SIMBOLOS, ABREVIATURAS E SIGLAS
ix
RESUMO
x
ABSTRACT
This work presents softwares developed using Java language to provide communication
between mobile devices and personal computers through the Bluetooth standard. It was split in
four stages where concepts concepts, tools and implementations are showed. Two technologies
will be presented: in the first stage Bluetooth will be explored, its characteristics and differences
between Bluetooth and anothers wireless technologies. We also show the Java programming
language and its environments of development for different kinds of device. In the following
stage, we explore MIDP (the Java profile for portable devices), of the Application Program
Interface Javax.Bluetooth also presenting the used tools of development. With applied the initial
and specific basement already, the third stage of this work presents the projects implemented
through the Java language and of the Bluetooth technology. These projects enclose three
softwares: a Chat between mobile devices (cellular-cellular), a Chat between personal
computers, and anoter Chat that uses the results of the previous projects and establishes the
communication between a mobile device and a personal computer. With these implementations
and study of the technologies, the fourth and last stage of this work presents the difficulties and
possibilities of this universe of development.
xi
CAPÍTULO 1 – INTRODUÇÃO
1
Conhecendo a forma de funcionamento do padrão Bluetooth para conexão de dispositivos, pode-
se aplicar este conhecimento para desenvolver aplicativos dos mais diversos que utilizem esta
tecnologia, diminuindo drasticamente a quantidade de cabos necessários para se manter um
conexão entre os dispositivos próximos e facilitando a comunicação entre dispositivos que
utilizam interfaces diferentes, mas que tenham em comum o suporte ao Bluetooth. Para que seja
possível implementar uma comunicação entre os dispositivos via rádio Bluetooth, é necessário
conhecer o ambiente de desenvolvimento que cada dispositivo suporta. Para desenvolvimento
deste trabalho será utilizada a linguagem de programação Java, devido a vasta gama de
dispositivos com suporte a esta linguagem. A linguagem Java, desenvolvida pela Sun
Microsystems com o objetivo de fornecer ao programador um ambiente de programação
independentemente de plataforma, também é apresentada no Capítulo 2. Sobre o Java, será
apresentando o conceito de máquina virtual, onde todo programa é desenvolvido baseado nos
recursos disponíveis nessa ‘máquina’, enquanto que para cada plataforma é implementada uma
comunicação entre essa máquina virtual e o sistema operacional. Dessa forma torna-se possível
que um programa desenvolvido para ambiente windows seja executado em ambiente linux e vice-
versa sem necessidade de mudanças no código fonte, isso porque o código é desenvolvido para a
máquina virtual e a Sun Microsystems disponibiliza uma máquina virtual adequada a cada um
dos dois sistemas.
Entendendo que “tamanho único” não se adapta a todas as necessidades, a Sun
Microsystems lançou em 1999 uma edição da sua plataforma chamada Java 2 Micro Edition
(J2ME). Essa edição tem enfoque em ambientes cujos recursos são limitados, ou seja, sistemas
embarcados e produtos de consumo tais como celulares, PDA`s, entre outros. A J2ME oferece
suporte a vários tipos de dispositivos, modularizados através de configurações, perfis e
bibliotecas específicas. Apesar de haver citação conceitual sobre estes assuntos no Capítulo 2, o
foco no perfil específico para celulares e dispositivos móveis (MIDP), assim como na biblioteca
específica para o padrão Bluetooth (API Javax.Bluetooth), é dado no Capítulo 3, onde as são
apresentadas as ferramentas e tecnologias utilizadas neste trabalho. Neste capítulo são
apresentados os softwares da Sun Microsystems e da Nokia que auxiliam o trabalho com
dispositivos celulares, ambientes de desenvolvimento, simuladores e compiladores da linguagem
Java.
Percebe-se que a união dessas duas tecnologias abre um enorme potencial de novas
2
aplicações, pois a maioria dos dispositivos móveis que disponibilizam interface de programação
ao usuário também oferecem suporte ao Java. O mercado de aplicações destas tecnologias vai
desde um simples Chat até as mais ousadas e promissoras idéias. Os projetos implementados são
apresentados no Capítulo 4, onde três projetos de Chat são desenvolvidos. Os três projetos têm
uma seqüência, onde primeiro a comunicação é estabelecida entre celulares, implementando no
ambiente J2ME. Em seguida é desenvolvido um Chat entre computadores pessoais, utilizando o
J2SE. Por fim, o terceiro projeto implementa os dois anteriores, realizando um Chat entre
computador pessoal e celular.
Apesar do grande potencial e do fato da indústria lançar cada vez mais produtos com
estes recursos, são poucas as criações nesta área. Acreditamos que esse fato se deva
principalmente a escassez de informações técnicas. Por isto, este trabalho se propõe a servir de
referência técnica no estudo básico das tecnologias Bluetooth e J2ME, de modo a fornecer
embasamento teórico para a criação de aplicações futuras. Estas e outras conclusões, assim como
as principais dificuldades enfrentadas neste trabalho, são expostas no Capítulo 5.
3
CAPÍTULO 2 – FUNDAMENTAÇÃO TEÓRICA
4
2.1.1 Modo de funcionamento
5
Figura 2.1 - Ilustração do conceito de célula.
6
Direct Sequence) e Salto de Freqüência (FH – Frequency Hopping). Os sistemas DS são
baseados na amplitude modulada (AM), enquanto que os FH são baseados na freqüência
modulada (FM) [3].
Conforme comentado, o método de transmissão por espectro espalhado utiliza uma faixa
de freqüência (várias freqüências de transmissão) em vez de utilizar uma única freqüência fixa.
Essa faixa de freqüência normalmente é dividida em canais.
7
Figura 2.2 - Transmissão FHSS [2].
2.1.2.5 Microondas
Esta tecnologia oferece uma taxa de transmissão equivalente a do padrão Ethernet
(10Mbps), podendo atingir taxas superiores. A faixa de freqüência usada é em torno de 18 a 19
GHz (entre as ondas de rádio e o infravermelho) [3].
2.1.2.6 Infravermelho
A tecnologia infravermelho em vez de utilizar ondas de rádio, utiliza luz infravermelha
para fazer a transmissão de dados. Existem dois métodos para a transmissão de dados usando luz
infravermelha: a transmissão direta e a transmissão difusa. Na transmissão direta, os dispositivos
transmissores e receptores possuem um ângulo de abertura pequeno e, com isso, precisam estar
alinhados para que a transmissão possa ser efetuada. Já na transmissão difusa, os sinais
9
infravermelhos são enviados em todas as direções. Em termos práticos, a transmissão difusa
obtém uma taxa de transmissão menor e uma área de alcance menor que a direta.
Para WPANs:
ü Protocolo IEEE 802.15
ü Bluetooth
ü HomeRF
ü IrDA
10
para transmissão de dados FHSS, DSSS ou Infravermelho.
Verificando a extrema necessidade de velocidade, os fabricantes comecaram a
apresentar equipamentos com protocolos proprietários para aumentar a taxa de transferência para
10Mbps, o mesmo do Ethernet IEEE 802.3 [2].
Diante deste fato o IEEE definiu dois padrões para complementar a velocidade
requerida, são eles:
ü IEEE 802.11a – Trabalha na freqüência de 5GHz e suporta taxa de transferência
de 54Mbps;
ü IEEE 802.11b – Trabalha na freqüência de 2.4GHz e suporta taxa de
transferência de 11Mbps;
Na arquitetura 802.11 a unidade básica é a célula, que é composta de uma ou mais
estações de trabalho sem fio e um access point.
11
O sistema do núcleo de Bluetooth consiste em um transceptor RF. O sistema oferece os
serviços que permitem a conexão entre dispositivos e da troca de dados entre estes dispositivos.
12
comunicações entre as piconets são filtradas pelos dispositivos mestres das piconets individuais.
Até 10 piconets contendo um total de 80 dispositivos Bluetooth diferentes podem ser incluídas
em uma única scatternet, além desse número a rede fica saturada. Como as piconets têm
identidades diferentes baseadas em canais de salto de freqüência diferentes, diversas piconets
podem compartilhar o mesmo espaço físico sem intervir entre si [2].
Apesar de um dispositivo Bluetooth poder participar de mais de uma piconet não é
possível que um dispositivo seja o mestre de mais de uma piconet ao mesmo tempo uma vez que
o clock sincronização da piconet é baseado no clock do dispositivo mestre. Em contrapartida um
dispositivo pode ser escravo em várias piconets independentes, a Figura 2.3 ilustra esse exemplo,
o dispositivo D faz parte das piconets 1 e 2. Um dispositivo que seja membro de duas ou mais
piconets não obrigatoriamente desempenhará funções de roteamento entre essas piconets. Apesar
de poder fazer parte de mais de uma piconet ao mesmo tempo um único dispositivo não pode ser
mestre de mais de uma piconet isso porque a alternância de freqüência é definida baseada no
clock do dispositivo e nesse caso seria a mesma para as duas piconets o que causaria interferência
nas transmissões.
13
do Bluetooth com sistemas ISM estáticos que compartilham o mesmo ambiente [6].
Os sinais de dados utilizam a tecnologia baseada em comutação de pacote. Eles podem
ser transmitidos por rotas, freqüências e ordem diferentes da original. Uma vez que os pacotes de
uma mensagem sejam recebidos, eles serão reordenados na sua seqüência original. Já o sinal de
voz, por outro lado utiliza a tecnologia denomiada de comutação de circuito. Com ela, as
mensagens não são fatiadas em pacotes, em vez disso, um canal dedicado (ou circuito) é
estabelecido durante a transmissão. A taxa de transferência total de 1Mbps da tecnologia é o
máximo teórico, as taxas de transferências efetivas variam de acordo com o tipo de comunicação
[2].
De acordo com a especificação, cada freqüência é subdividida em unidades de tempo
conhecida como slots. Os dados são transmitidos entre dispositivos Bluetooth em pacotes que são
posicionados nesses slots. Quando as circunstâncias permitem, um número de consecutivos slots
pode ser alocado em um único pacote. A tecnologia Bluetooth oferece o efeito de transmissão
full-duplex através do uso do esquema de TDD (Time-Division Duplex). Nesse sistema cada slot
de tempo tem 625ms de duração, o TDD atribui slots de tempo subseqüentes para transmissão e
recepção. As unidades mestras transmitem em unidades pares, enquanto as escravas transmitem
nos slots ímpares.
Em nível físico, consideramos um circuito quando se estabelece uma conexão entre dois
dispositivos que transmitem pacotes em ambas as direções entre eles. Na arquitetura piconet
existem restrições no que diz respeito à formação desses circuitos. Existe um circuito entre cada
escravo e o mestre, porém não existem circuitos conectando diretamente dois escravos [6].
Todos os dispositivos Bluetooth que não estejam conectados a uma piconet iniciam no
estado de baixo consumo de energia. Quando uma unidade percebe outro dispositivo Bluetooth
na área, um procedimento de conexão é iniciado. Neste momento o primeiro dispositivo (que
encontrou o segundo) se torna mestre e formará uma piconet.
15
2.2.4 Gerenciador de Link e Controlador de Link
Dispositivo Dispositivo
realizando encontrado
busca
◄––––––––––––––––––––► Busca e localização de dispositivo
LMP, Requisição de:
ü Diferença (offset) de clock;
ü Versão do LMP;
◄––––––––––––––––––––►
ü Recursos suportados;
ü Nome;
ü Desconexão (opcional);
––––––––––––––––––––––► LMP, Requisição de conexão.
◄–––––––––––––––––––––– LMP, Resposta de conexão aceita ou conexão recusada.
◄––––––––––––––––––––► LMP, Procedimentos de autenticação e criptografia.
––––––––––––––––––––––► LMP, Mensagem de configuração completa.
◄–––––––––––––––––––––– LMP, Mensagem de configuração completa.
16
2.3 JAVA
Neste item será abordada a tecnologia Java para programação. Suas características de
portabilidade assim como sua plataforma com foco em dispositivos que possuem poucos
requisitos de hardware, a tornou a linguagem predominante nos dispositivos móveis, um dos
focos deste projeto.
17
2.3.2 Divisão da família JAVA
18
2.3.3 J2ME
A plataforma J2ME provê um ambiente robusto e flexível para aplicações que rodam em
dispositivos como celulares, pagers, PDA’s e uma outra grande gama de dispositivos de baixo
poder de processamento e armazenamento. Assim como as plataformas J2EE e J2SE, a J2ME
inclui máquinas virtuais e vários API’s padrões definidos pela Sun Microsystems e comunidades
Java (comunidades de peritos, fabricantes, vendedores e prestadores de serviço de dispositivos
que utilizam a J2ME).
A J2ME inclui dispositivos de interface flexíveis com o usuário (isto devido a grande
variedade de displays, que variam em cada modelo de aparelho), um modelo de segurança
robusto, uma grande variedade de protocolos de rede embutidos, além de suporte a aplicativos em
rede ou off-line, que podem ser carregados dinamicamente [10].
A arquitetura do J2ME inclui uma variedade de configurations, profiles, e API’s que o
programador pode escolher, combinando-os para construir um ambiente completo que se ajuste
ao dispositivo e às necessidades do aplicativo. Estas combinações visam aperfeiçoar o aplicativo
para a capacidade de memória, poder de processamento e particularidades dos periféricos de E/S
(entrada e saída) da uma determinada categoria de dispositivos. O resultado é uma plataforma
Java comum a todos os dispositivos e que tira proveito de cada um de forma aperfeiçoada [10].
Um exemplo da capacidade de otimização do J2ME para com as limitações físicas do
dispositivo é a dualidade de configurations, que podem se adequar às características do
dispositivo para o qual se está desenvolvendo o aplicativo, hoje existem duas configurations para
esta plataforma, a ‘CLDC’ e ‘CDC’, que diferem na quantidade de recursos suportados e
disponibilizados para o programador [9].
2.3.4.1 JVM
A Máquina Virtual Java usada nas versões Standard Edition e Enterprise Edition é
19
voltada apenas para o uso em computadores convencionais e servidores. Já no caso dos
dispositivos de pequeno porte, necessitam de uma Máquina Virtual adequada as suas arquiteturas
como Celulares, Telefones Inteligentes, Pagers, PDA’s, etc.
Porém, a VM para estes dispositivos de pequeno porte também leva em conta a mesma
dualidade das configurations, ou seja, a Sun Microsystems desenvolveu duas VM´s para atender
ao mercado do J2ME. Nesta plataforma, o Java dispõe de duas VM´s, a KVM e a CVM, uma
para desenvolvimento e aplicações em dispositivos com pouca memória e pouco poder de
processamento (dispositivos de baixo desempenho) e a outra para dispositivos com um pouco
mais de memória e melhor poder de processamento (dispositivos de alto desempenho). Os
dispositivos de baixo desempenho utilizam KVM (K Virtual machine, ou Máquina Virtual K) e
os dispositivos de alto desempenho utilizam a CVM (C Virtual machine, ou Máquina Virtual C)
[11].
2.3.4.2 KVM
O surgimento do J2ME trouxe consigo uma máquina virtual bastante otimizada. O KMV
é uma pequena VM com o mínimo de API´s incluídas. A letra K no nome da VM faz referencia a
palavra ‘kilo’, indicando que o tamanho da VM é dimensionado em kilobytes, e não em
megabytes. A KVM é otimizada para dispositivos de baixo desempenho, e o seu tamanho está
entre 40 e 80 KB [10].
A KVM pode rodar em sistemas com processadores de 16 e 32 bits e de 160 a 512 KB
de memória e não tem suporte a dados do tipo inteiro longo e ponto flutuante, isto porque o
design da KVM é baseado em considerações importantes, incluindo o pequeno tamanho para
conservar a maior quantidade possível de espaço na memória do dispositivo (tanto em termos de
armazenamento quanto de execução) para assegurar a portabilidade [11].
Devido a grande quantidade de dispositivos com características diferentes e que utilizam
o J2ME, a Sun Microsystems dividiu a plataforma em duas configurations, conforme já
mencionado, a CDC e CLDC, esta configurations são quem definem as características da VM a
ser utilizada, e através delas é que se escolhe quais API´s serão utilizadas. Sendo a KVM
desenvolvida para trabalhar com o CLDC.
20
A Máquina Virtual K teoricamente pode rodar vários Profiles, mas isso não significa
que vai rodar perfeitamente todos Profiles e API’s, pois podem não ter sido especificamente
desenvolvidas para a KVM. Esta VM não pode ser usada, por exemplo, para rodar a CDC.
Isto que dizer que não dá para fazer com que as aplicações desenvolvidas para CVM
sejam executadas na KVM sem as devidas modificações. Já o contrario é verdadeiro, isto é, uma
aplicação feita em KVM roda em CVM ou JVM [9].
2.3.4.3 CVM
2.3.5 Configurations
21
dispositivos, determinando assim quais as características da VM (KVM ou CVM) adequada.
2.3.5.1 CLDC
Essa configuração foi desenvolvida para dispositivos com baixos recursos de memória
(entre 160 kB e 512 kB de memória), baixo poder de processamento (processadores de 16 ou 32
bits) e baixo consumo de energia (funcionam com bateria) como os telefones celulares, PDA’s,
pagers etc. Com vista nisso, toda a tecnologia Java foi otimizada para prover funcionalidade para
este grupo de dispositivos. A Máquina Virtual K como já foi citado beneficia muito esta
configuration pela característica de ser muito pequena, e não ter todos os recursos de uma JVM.
O maior destaque é que mesmo com poucas bibliotecas disponíveis conseguem permitir que as
configurations implementem a execução de diversas funcionalidades. Porém, mesmo assim, elas
devem ser usadas com muito cuidado, já que os dispositivos não dispõem de muita memória [12].
2.3.5.2 CDC
2.3.6 Profiles
22
chamadas API´s [13].
As API’s têm foco em um determinado dispositivo, como celulares ou PDA´s, porém
não são desenvolvidas sobre as características de um dispositivo específico, na verdade os
fabricantes é que implementam, de acordo com o desejado, as execuções desenvolvidas nos
profiles. Porém, existe a opção de adicionar pacotes extras de API´s, que podem ser
desenvolvidas para uma determinada aplicação em um determinado dispositivo, como por
exemplo, conexões Bluetooth e alguns serviços web. Estes pacotes, mesmo depois de
desenvolvidos, geralmente não são incluídos como padrão nos profiles, pois uma preocupação
inicial das bibliotecas de API´s é a otimização. Na Tabela 4.1 temos uma demonstração de alguns
profiles e suas aplicações e configurations [9],[13].
2.3.6.1 MIDP
24
memória, limitada capacidade de entrada/saída de dados, enfim, dispositivos de baixo
desempenho. Sendo utilizado principalmente em aparelhos celulares, pequenos PDA´s e pagers
[9].
As aplicações desenvolvidas em MIDP são chamadas de MIDlets, e podem utilizar as
API´s do perfil e API´s opcionais que podem ser adicionadas se desejado. Porém, os MIDlets não
têm acesso todas as API´s de alguns dispositivos, como por exemplo a API do celular que, para
evitar que usuários mal intencionados desenvolvam programas para acessar esta API nativa dos
celulares e possam modificar os dados do dispositivo, é mantida em uma memória independente
da VM dos MIDlets [9],[10].
Outro ponto importante é que a carga de classes definidas pelo usuário não é permitida,
ou seja, o usuário não tem acesso a outras funções que não seja as da VM, o que aumenta a
segurança, porém restringe um pouco o desenvolvimento [9].
Os fabricantes de dispositivos podem fornecer API’s especificas para desenvolvimento
de aplicações, como é o caso dos jogos nos celulares. Cada fabricante disponibiliza sua própria
API para os jogos, podendo assim aproveitar melhor o desempenho do celular e seus recursos
proprietários. Esta prática compromete a portabilidade do Java, mas é desejável em algumas
situações, principalmente quando o fabricante cria um diferencial em seu produto [9].
ü Entrada:
Mínimo de um dispositivo de entrada tipo teclado, ou touch-screen;
Suporte a teclado numérico, bastante utilizado em celulares, a teclado alfa-numérico
utilizado em PDA´s e alguns celulares, e a telas sensíveis ao toque – conhecidas também como
25
touch-screen – comum em PDA´s. Outros dispositivos podem ser adicionados através de inclusão
de API´s específicas.
ü Memória:
128 kB de memória não-volátil para os componentes MIDP;
8 kB de memória não-volátil para os dados dos MIDlets criados
32 kB de memória volátil para runtime;
As mínimas condições de funcionamento do MIDP exigem uma pequena quantidade de
memória do dispositivo, que deverá oferecer disponibilidade de 128kB de memória não-volátil
para o armazenamento do MIDlet e dos componentes MIDP, uma disponibilidade adicional de
8kB de memória persistente para os dados do MIDlet que devem ser guardados durante e após a
execução da aplicação além de um mínimo de 32kB de memória volátil (tipo RAM) para rodar o
MIDlet. Esta memória de troca deverá ser observada pelo programador durante a construção de
seu projeto, para não comprometer o desempenho ou até mesmo as condições de execução do
aplicativo programado.
Este profile provê um mecanismo de gravação de dados (memória persistente) que
permite a gravação de dados e sua leitura posterior, chamado RMS (Record Management System,
ou Sistema de Gerência de Gravação). Este sistema provê a gravação de dados persistentes na
memória durante inúmeras solicitações do aplicativo, e deve manter a integridade destes dados,
mesmo em condições de falta de alimentação ou descarregamento de baterias do dispositivo
como, por exemplo, ocorre com a agenda de um aparelho celular durante a troca de baterias [9]
[10].
ü Rede:
Duas vias, com ou sem fios, com banda limitada.
O MIDP suporta conexões de rede de acordo com os recursos do dispositivo. As
conexões sem fio (wireless) são as mais utilizadas em dispositivos portáteis, porém há também
utilização de conexões através de cabos. Com o aumento da utilização da tecnologia Bluetooth,
esta tem se fortalecido como uma parceira forte do MIDP em conjunto com o CLDC, merecendo
até API´s específicas sobre este tecnologia wireless em dispositivos portáteis [13].
26
2.3.6.1.2 MIDP MIDlets suítes
27
CAPÍTULO 3 – TECNOLOGIAS DE SOFTWARE
3.1.1.1 DiscoveryListener
A interface DiscoveryListener permite que uma aplicação receba os eventos de
descoberta de dispositivo - device discovery - e descoberta de serviço - service discovery. Esta
interface fornece quatro métodos, dois de descoberta de dispositivos e dois de descoberta de
serviços.
3.1.1.1.1.1 Sintaxe:
public void deviceDiscovered(RemoteDevice btDevice,
DeviceClass cod)
3.1.1.1.1.2 Parâmetros:
dispositivo remoto.
28
3.1.1.1.2 Método servicesDiscovered
Este método é chamado quando serviços são encontrados durante uma busca por
serviços.
3.1.1.1.2.1 Sintaxe:
public void servicesDiscovered(int transID,
ServiceRecord[] servRecord)
3.1.1.1.2.2 Parâmetros:
resultados.
service – Lista de serviços encontrados durante a requisição de busca.
respCode Descrição
SERVICE_SEARCH_COMPLETED Busca por serviços foi concluída com
sucesso.
SERVICE_SEARCH_TERMINATED Busca por serviços foi interrompida
através da chamada
DiscoveryAgent.cancelServiceSearch().
SERVICE_SEARCH_ERROR Ocorreu um erro durante o
processamento da busca de serviços.
SERVICE_SEARCH_NO_RECORDS Não foi encontrado nenhum serviço
durante a busca.
SERVICE_SEARCH_DEVICE_NOT_REACHABLE O dispositivo especificado na busca não
foi encontrado ou o dispositivo local foi
incapaz de conectar ao dispositivo
remoto.
29
3.1.1.1.3.1 Sintaxe:
public void serviceSearchCompleted(int transID,
int respCode)
3.1.1.1.3.2 Parâmetros:
serviços.
respCode – O código de resposta que indica o status da transação.
3.1.1.1.4.1 Sintaxe:
public void inquiryCompleted(int discType)
3.1.1.1.4.2 Parâmetros:
30
3.1.1.2 L2CAPConnection
A interface L2CAPConnection representa um canal L2CAP orientado a conexão. Esta
interface é usada como parte do Framework de conexão genérica do CLDC. Para criar uma
conexão de cliente, o protocolo a ser usado é o btl2cap. O destino é uma combinação de endereço
de dispositivo Bluetooth a ser conectado e o PSM do serviço. O valor PSM é usado pelo L2CAP
para determinar qual a camada de protocolo ou aplicação é destinatária das mensagens. O
parâmetro definido especificamente para o L2CAP é o ReceiveMTU (MTU – Maximum
Transmission Unit, Unidade de Transmissão Máxima de recebimento) e o TransmitMTU
(Unidade de Transmissão Máxima do transmissor). O ReceiveMTU e o TransmitMTU são
parâmetros opcionais. Um exemplo de uma string válida de conexão L2CAP é:
btl2cap://0050CD00321B:1003;ReceiveMTU=512;TransmitMTU=512
No exemplo acima, podemos identificar:
• Endereço do dispositivo Bluetooth: 0050CD00321B;
• PSM: 1003;
• ReceiveMTU: 512;
• TransmitMTU: 512.
3.1.1.2.1.1 Sintaxe:
public int getReceiveMTU()
throws Java.io.IOException
3.1.1.2.1.2 Retorno:
O número máximo de bytes que podem ser lidos em uma única chamada de receive().
31
3.1.1.2.2 Método getTransmitMTU
Retorna o MTU que o dispositivo remoto suporta. Este valor é obtido após a conexão ter
sido configurada. Se a aplicação houver especificado o TransmitMTU na string
Connector.open(), então o retorno sera igual ao valor especificado. Se a aplicação não
especificar nenhum TransmitMTU, então o valor sera menor ou igual ao valor de ReceiveMTU
que o dispositivo remoto informou na configuração do canal.
3.1.1.2.2.1 Sintaxe:
public int getTransmitMTU()
throws Java.io.IOException
3.1.1.2.2.2 Retorno:
O número máximo de bytes que podem ser enviados em uma única chamada do send(),
sem que nenhum dado seja perdido.
3.1.1.2.3.1 Sintaxe:
public boolean ready()
throws Java.io.IOException
3.1.1.2.3.2 Retorno:
32
3.1.1.2.4 Método receive
Lê um pacote de dados. A quantidade de dados recebidos em uma operação é
determinado pelo ReceiveMTU. Se o tamanho de inBuf for maior ou igual ao
ReceiveMTU, nenhum dado sera perdido. Diferentemente do read() da
Java.io.InputStream, se o tamanho do inBuf for menor que o ReceiveMTU, então os
dados no pacote L2CAP que caibam no inBuf serão armazenados, e os demais serão
descartados. Se o inBuf tiver comprimento 0, todos os dados no pacote recebido serão
perdidos, exceto se o pacote for de comprimento 0.
3.1.1.2.4.1 Sintaxe:
public int receive(byte[] inBuf)
throws Java.io.IOException
3.1.1.2.4.2 Parameters:
3.1.1.2.4.3 Retorno:
33
for maior que o TransmitMTU, somente os primeiros bytes do pacote serão enviados, e o
restante dos bytes de data que estiverem além do tamanho do TransmitMTU serão
descartados. Se data tiver comprimento 0, um pacote L2CAP vazio sera enviado.
3.1.1.2.5.1 Sintaxe:
public void send(byte[] data)
throws Java.io.IOException
3.1.1.2.5.2 Parametros:
3.1.1.3 L2CAPConnectionNotifier
A interface L2CAPConnectionNotifier provê um notificador de conexão L2CAP.
Para criar um conexão de servidor, o protocolo a ser utilizado é o btl2cap. O alvo é
"localhost:" e a UUID do serviço desejado. Os parametros são ReceiveMTU e TransmitMTU, os
mesmos usados para definir uma conexão de cliente. Abaixo segue um exemplo de uma string
válida para um conexão de servidor:
btl2cap://localhost:3B9FA89520078C303355AAA694238F07;ReceiveMTU=512;Tra
nsmitMTU=512
Chamando o método Connector.open() com a string acima retornará um objeto
Javax.Bluetooth.L2CAPConnectionNotifier. Um objeto L2CAPConnection é obtido do
34
L2CAPConnection que poderá ser usada para comunicação com este cliente.
3.1.1.3.1.1 Sintaxe:
public L2CAPConnection acceptAndOpen()
throws Java.io.IOException
3.1.1.3.1.2 Retorno:
35
modo conectável devido ao usuáio ter configurado o dispositivo como não-conectável.
3.1.1.4 ServiceRecord
A interface ServiceRecord descreve as características de um serviço Bluetooth. O
ServiceRecord contem os atributos de configuração de um serviço, ondes estes atributos são um
par de configurações formados por ID e value. O atributo ID do Bluetooth é um inteiro de 16-bit,
e o atributo value é um DataElement.
A estrutura e o uso do ServiceRecords são definidos pela especificações de Bluetooth
Service Discovery Protocol (SDP). A maioria das especificações de perfis Bluetooth são descritas
na estrutura do ServiceRecord usado pelos serviços Bluetooth de cada perfil.
Um servidor SDP mantêm um Service Discovery Database (SDDB) de ServiceRecords
que descrevem os serviços no dispositivo local. Já os clientes SDP remotos podem usar o SDP
para questionar um servidor SDP sobre qualquer ServiceRecords de seu interesse. Um
ServiceRecord provê informações suficientes para permiitir a um cliente SDP conectar o serviço
Bluetooth no dispositivo do servidor SDP.
ServiceRecords são disponibilizados ao aplicativo cliente através de um argumento do
método servicesDiscovered da interface DiscoveryListener. O ServiceRecords é disponibilizado
para o aplicativo servidor através do método getRecord() no dispositivo local.
Podem haver vários atributos de serviços em um mesmo ServiceRecord, e o protocolo
SDP torna possível especificar o subconjunto de atributos de service que o cliente SDP receber
do ServiceRecord remoto. A interface ServiceRecord trata alguns atributos IDs de serviço como
IDs padrão, desta forma, esses serviços são automaticamente identificados durante uma busca de
serviços.
Existe um documento que define uma grande quantidade de números IDs padrões para
assinatura de atributos de serviços Bluetooth, este documento poderá ser obtido através do site na
internet: https://www.Bluetooth.org/foundry/assignnumb/document/service_discovery.
36
3.1.2 Classes
A seguir são apresentadas as classes que compõem o pacote Bluetooth da API de mesmo
nome. Alguns métodos citados não estão detalhados devido a sua simplicidade, mas estão
disponíveis em sua íntegra no CD Anexo deste projeto.
3.1.2.1 DataElement
A classe DataElement define os vários tipos de dados a que atributos e serviços do
Bluetooth podem pertencer. A Tabela 3.3 apresenta os tipos de dados e valores válidos para
armazenamento em um objeto DataElement.
3.1.2.2 DeviceClass
A classe DeviceClass representa a classe do dispositivo - class of device (CoD) – que
37
registra as definições da especificação Bluetooth. Este registro é definido no documento de
números Bluetooth assinados - Bluetooth Assigned Numbers – e contem informações do tipo de
dispositivo e dos tipos de serviços disponíveis neste dispositivo.
O documento Bluetooth Assigned Numbers pode ser encontrado na internet
(https://www.Bluetooth.org/foundry/assignnumb/document/baseband), com as definições de
classes de dispositivos e serviços, dentre outras informações.
3.1.2.3 DiscoveryAgent
Uma classe DiscoveryAgent provê métodos para permitir a descoberta de dispositivos e
serviços. Um dispositivo local possui apenas um objeto DiscoveryAgent. Este objeto é retornado
a partir de uma chamada do getDiscoveryAgent() no objeto LocalDevice.
retrieveDevices(). Este método irá retornar os dispositivos que já foram descobertos através
38
determinado dispositivo, o método selectService() realiza a busca pelo serviço independente
do dispositivo em que este serviço possa estar, abrangendo todos os dispositivos remotos
disponíveis.
3.1.2.4 LocalDevice
A classe LocalDevice define as funções básicas do gerenciador Bluetooth - Bluetooth
Manager. O Bluetooth Manager provê o mais baixo nível de interface possível de acesso à pilha
do Bluetooth. Este acesso é provido e controlado pelo dispositivo local.
Esta classe produz um único objeto. Os detalhes dos métodos desta classe podem ser
consultados no CD anexo deste projeto.
3.1.2.5 RemoteDevice
A classe RemoteDevice representa um dispositivo Bluetooth remoto. Ela provê as
informações básicas sobre o dispositivo remoto, inclusive o endereço, nome de contato - friendly
name – e outras informações registradas no LocalDevice do dispositivo remoto representado.
3.1.2.6 UUID
A classe UUID define os identificadores únicos universais - universally unique
identifiers. Estes identificadores são números inteiros positivos de 128-bit, o que garante que
sejam únicos.
A especificação do SDP – Service Dicovery Protocol – Bluetooth define uma forma de
representar um UUID de 128-bit em formas menores de 16-bit e 32-bit, subdividindo em
intervalos. O primeiro intervalo de 232 valores é chamado de uuid32, e pode-se dele obter um
intervalo menor de 216 chamado uuid16. Toda a definição de campos utilizados e reservados é
determinada pela IEEE, ISO e Bluetooth.org, que controlam as alterações e padronizações para
identificação de fabricantes e serviços no UUID. Esta especificação pode ser obtida através do
site: (https://www.Bluetooth.org/foundry/assignnumb/document/assigned_numbers).
39
3.1.3 Exceções
3.1.3.1 BluetoothConnectionException
A exceção BluetoothConnectionException acontece quando uma conexão Bluetooth
(L2CAP, RFCOMM, or OBEX over RFCOMM) não pôde ser realizada com sucesso. Os campos
na classe desta exceção indicam a causa de sua ocorrência, repassando ao aplicativo a razão da
falha de uma determinada conexão que não pôde ser estabelecida.
3.1.3.2 BluetoothStateException
A exceção BluetoothStateException é acionada quando uma requisição feita pelo
sistema ao Bluetooth não pode ser atendida no estado atual do sistema, mas poderia ser
completada se o sistema estivesse em um outro estado. Isto acontece quando há
incompatibilidade de tarefas solicitadas com as tarefas que estão sendo executadas. Por exemplo,
alguns sistemas Bluetooth não permitem que o dispositivo entre em modo de busca se uma
conexão estiver estabelecida. Neste caso, se o método startInquiry() fosse chamado, esta
exceção seria acionada.
3.1.3.3 ServiceRegistrationException
A ServiceRegistrationException é uma exceção que informa uma falha na adição
de dados pelo ServiceRecord ao banco de dados local do ServiceDiscovery (SDDB) ou na
modificação de dados existentes no SDDB pelo ServiceRecord. Esta falha pode ser causada se o
SDDB não tiver onde alocar novos registros ou porque a modificação de dados pelo
ServiceRecord violou as regras de alteração de registro. Esta exceção também é acionada quando
não é possível obter um canal de servidor RFCOMM necessário para registrar um serviço btspp.
Para o desenvolvimento de um aplicativo Java, utilizando a plataforma J2ME, são
necessários softwares específicos, alguns distribuídos pela própria Sun Microsystems e outros que
podem ser encontrados na Internet em distribuições gratuitas. Neste capítulo são apresentados os
softwares que foram utilizados para desenvolver o primeiro aplicativo J2ME deste projeto,
direcionado para aparelhos celulares com suporte a tecnologia MIDP.
40
3.2 MIDlets:
41
Além dos arquivos de classe e recurso, um JAR contém um arquivo denominado
manifest.mf que é armazenado como parte do próprio arquivo JAR e carrega uma lista de
atributos para identificação da aplicação. A Tabela 3.4 mostra os atributos de sistema que podem
ser definidos dentro desse arquivo.
Além de um arquivo JAR, um arquivo JAD deve estar disponível como parte do
conjunto de MIDlets para fornecer informações sobre a(s) MIDlet(s) dentro do arquivo JAR. A
idéia por trás da inclusão de um arquivo JAD é:
1. Fornecer informações para o gerenciador de aplicativos sobre o conteúdo de um
arquivo JAR. Com esas informações, podem ser tomadas decisões quanto a uma
ou mais MIDlets serem convenientes para executar no dispositivo.
2. Fornecer um meio para que parâmetros sejam passados de uma MIDlet, sem ter
de fazer alterações no arquivo JAR.
A Tabela 3.5 mostra a lista de atributos de sistema que podem estar dentro de um
arquivo JAD.
43
MIDlet-Data-Size O número mínimo de bytes exigido para Não
armazenamento de dados persistentes.
MIDlet-Description Texto descrevendo a MIDlet. Não
MIDlet-Delete-Confirm Mensagens mostradas pa ra um usuá rio Não
confirmar um pedido de exclusão de um
conjunto de MIDlet.
MIDlet-Install-Notify URL a ser notificada sobre status da Não
instalação.
Para que o gerenciador de aplicativos execute uma MIDlet não se faz necessária a
existência de um arquivo JAD, esse arquivo simplesmente fornece um meio para que o
gerenciador saiba o que está contido no arquivo JAR. Com essa informação o gerenciador de
aplicativos pode tomar decisões, tais como se deve fazer o download ou não do aplicativo uma
vez que o atributo MIDlet-Jar-Size especifica o tamanho do arquivo, logo se um dispositivo
possuir uma capacidade de memória inferior ao tamanho do arquivo JAR o gerenciador de
aplicativos pode alertar para esse erro antes mesmo de se tentar descarregar todo o arquivo da
internet.
Para que se possa desenvolver e empacotr MIDlets, são necessáros pelo menos três
pacotes de software:
1. Java 2 SDK 1.4 ou superior, disponível em: http://Java.sun.com/j2se
44
2. CLDC 1.1 ou superior, disponível em: http://Java.sun.com/products/cldc
3. MIDP 2.0 ou superior: http://Java.sun.com/products/midp
46
Figura 3.1 - Testando a instalação do ambiente de desenvolvimento.
3.2.5.4.1 Compilando
Nesse caso a execução da compilação do exemplo acima se daria pelo comando midletc
Arquivo. Outros recursos poderiam ser adicionados ao midletc.bat, porém não serão enfocados
neste trabalho pois daremos preferência a utilização de outra ferramenta detalhada mais a frente.
A simulação funciona bem para testes e depuração. Após esse passo para se transferir o
MIDlet para um dispositivo se faz necessário empacotar o MIDlet, conforme a sequencia abaixo:
49
do arquivo JAR, deverá ser executado o comando a seguir:
Para a criação do arquivo JAD, basta utilizar um editor de texto qualquer e inserir as
informações relativas a aplicação conforme descrito anteriormente.
Para que seja possível a instalação e execução do WTK se faz necessária a instalação
prévia do SDK. O ambiente de aplicativos proposto anteriormente para o desenvolvimento por
linha de comando é recomendável.
O WTK quando instalado apresenta vários ícones para o usuário, fornecendo opções de
configuração do dispositivo de emulação, consulta a documentação (guia de usuário, faq´s,
especificações da Sun Microsystems, etc.), barra de ferramentas, configurações de utilitários e
uma opção de execução rápida de aplicativos MIDP, conforme Figura 3.2.
51
Figura 3.3 - Tela principal do KToolBar.
Ao se escolher a opção de criação de novo projeto (botão New Project), uma caixa de
diálogo será exibida similar a Figura 3.4. Nessa caixa deve ser fornecido o nome do projeto e o
nome da classe MIDlet.
Uma vez escolhida a opção de criar projeto (botão Create Project), será mostrada uma
janela (Figura 3.5) solicitando as informações e configurações, essas configurações serão
utilizadas para criação dos arquivos JAD e de manifesto.
52
Figura 3.5 - Configurações do arquivo JAD.
Note que o atributo MIDlet-<n> não é mostrado na lista de atributos obrigatórios. Como
se trata de uma entrada para cada MIDlet do pacote, o WTK mostra esse atributo na aba MIDlets.
Conforme mostrado na Figura 3.6.
Na guia Optional (Figura 3.7) será possível configurar os atributos que não são
obrigatórios do arquivo JAD.
53
Figura 3.7 - Campos opcionais do arquivo JAD.
Ao criar um novo projeto no WTK, uma lista de subdiretórios será criada dentro do
diretório principal do projeto. Cada subdiretório tem uma finalidade específica são eles:
\bin – Arquivos de manifesto, JAD e JAR;
\classes – Arquivos de classe gerados pelo compilador Java;
\res – Todos os arquivos de recursos (imagens, dados, etc);
\src – Código-fonte Java;
\tmpclasses – Arquivos de classe previamente verificados.
Configurando o simulador.
Ao executar MIDlets que acessam a internet, pode ser necessário configurar um servidor
de proxy. Se isso for necessário, essa configuração deverá ser feita através do menu Edit,
Preferences.
Para que seja possível transferir aplicativos do computador para o telefone celular se faz
necessário que os dispositivos estejam pareados, ou seja, façam parte de uma mesma PAN e
tenham relações de confiança estabelecidas. Para fazer isso um dispositivo (pc ou celular) deverá
54
adicionar o outro a sua lista de dispositivos pareados, e o outro dispositivo deverá aceitar a
conexão bem como poderá ser estabelecida uma senha para ser usada nas conexões futuras entre
os dispositivos. Será abordada a conexão adicionando o dispositivo no pc e aceitando no telefone
celular por se tratar de um procedimento mais genérico.
Antes de iniciar a busca, é necessário que os serviços de Bluetooth estejam ativos em
ambos os dispositivos, tanto no celular quanto no computador. Para carregar o serviço Bluetooth
no Windows XP, acesse o painel de controle, ferramentas administrativas, serviços. O serviço
Bluetooth Suppport Service deverá estar iniciado. Recomenda-se que o tipo de inicialização desse
serviço seja definido como automático para que nas execuções futuras não seja necessário alterar
essa configuração. A Figura 3.8 mostra a janela de configuração do serviço, onde é possível
alterar o modo de inicialização, bem como parar e reiniciar o serviço
Figura 3.9 - Nokia 6230, tela Figura 3.10 - Nokia 6230, tela Figura 3.11 - Nokia 6230,
principal com Bluetooth principal com Bluetooth ativado. configurações.
desativado.
56
Figura 3.12 - Nokia 6230, menu Figura 3.13 - Nokia 6230, menu Figura 3.14 - Nokia 6230,
configurações. conectividade. configurações Bluetooth.
57
Figura 3.18 - Ativando ícone Bluetooth na área de notificação.
Em seguida deve-se fazer o mesmo procedimento que foi feito no celular, em relação a
tornar o dispositivo localizável, para isso basta marcar a opção ativar localização na tela de
configurações de dispositivos Bluetooth, conforme mostrado na Figura 3.19.
58
Figura 3.19 - Ativando localização no PC.
59
Figura 3.20 - Lista de dispositivos Bluetooth durante o primeiro acesso.
Será exibida a janela mostrada na Figura 3.21. Deverá ser marcada a opção: “Meu
dispositivo está instalado e pronto para ser localizado”.
60
Figura 3.21 - Tela de adição de dispositivo.
O windows fará uma busca pelos dispositivos próximos conforme mostrado na Figura
3.22 e em seguida exibirá uma lista dos dispositivos encontrados, conforme mostrado na Figura
3.23.
61
Figura 3.22 - Windows buscando por dispositivos próximos.
Ao clicar na opção avançar será mostrada uma tela conforme a da Figura 3.24. Nessa
62
tela é possível escolher se deverá ser utilizada uma senha para a conexão entre os dois
dispositivos. Qualquer das opções selecionadas terá o mesmo resultado.
Ao escolher o botão avançar, será mostrada a figura conforme Figura 3.25. Nesse ponto,
no equipamento celular será mostrada a tela perguntando se o usuário deseja parear com o
computador, conforme mostrado na Figura 3.26, e em seguida será requisitada a senha (Figura
3.27).
63
Figura 3.25 - Estabelecendo a conexão entre os dispositivos.
Figura 3.26 - Nokia 6230, tela de confirmação de Figura 3.27 - Nokia 6230, tela de requisição de senha
pareamento de dispositivo. para pareamento.
Uma vez fornecida a senha o celular realizará a troca de senhas com o computador
64
(Figura 3.28), caso não haja problemas a janela da Figura 3.29 será mostrada.
Figura 3.28 - Nokia 6230, confirmação de senha entre dispositivos sendo realizada.
Uma vez que o dispositivo tenha sido pareado com sucesso, o nome do novo dispositivo
será exibido na lista de dispositivos Bluetooth do Windows (Figura 3.30). Essa lista agrupa os
dispositivos por categoria, nesse caso o Nokia 6230 por se tratar de um equipamento telefônico é
listado na categoria Telefones e Modems.
65
Figura 3.30 - Lista de dispositivos Bluetooth pareados.
Após o pareamento, durante a primeira tentativa de acesso, o celular irá mostrar uma tela
de confirmação se deseja aceitar conexões do computador (Figura 3.31). Para evitar que essa tela
seja exibida novamente no futuro, na tela de dispositivos pareados (Figura 3.32), acesse selecione
o computador e escolha “opções”, na tela seguinte (Figura 3.33) mude o valor de conexão
automática sem confirmação para Sim.
66
Figura 3.33 - Nokia 6230, tela de
Figura 3.31 - Nokia 6230, tela de Figura 3.32 - Nokia 6230, lista de
opções de dispositivo pareado.
confirmação de conexão. dispositivos pareados.
68
Figura 3.35 - Nokia Connection Manager, adicionando novo telefone.
Uma vez que o celular já tenha sido cadastrado previamente, será exibida uma listagem
com os celulares com os quais é possível estabelecer conexão no momento. Deve-se selecionar o
celular para o qual deseja-se transferir o aplicativo e clicar no botão OK. Conforme mostrado na
Figura 3.36.
69
Figura 3.36 - Nokia Connection Manager, lista de telefones conhecidos.
Uma vez informado ao Nokia Connection Manager qual o celular que estará sendo
utilizado basta acionar o software Nokia Aplication Installer, que pode ser acessado através do
menu iniciar, conforme mostrado na Figura 3.37.
Observou-se que na versão 5.8 do Nokia PC Suíte existe uma falha que caso o Nokia
Aplication Installer seja carregado sem que o dispositivo esteja pareado ou conectado o software
não funcionará corretamente até a próxima reinicialização do sistema.
71
mas antes de ser iniciada a execução pelo gerenciador de aplicativos. Além disso,
após iniciada ela poderá alternar entre os estados ativo e pausa;
2. Ativa: A MIDlet está em execução;
3. Destruída: A MIDlet liberou todos os recursos que adquiriu e foi desligada pelo
gerenciador de aplicativos.
Cria-se uma MIDlet estendendo a classe MIDlet do J2ME. Essa classe é abstrata e inclui
três métodos abstratos, startApp(), destroyApp() e pauseApp(). De acordo com [16] a vantagem
de se usar uma classe abstrata é a “capacidade de encapsular o que considera,os uma
funcionalidade comum a todas as subclasses”, ou seja, com o uso desse recurso, qualquer
subclasse de uma MIDlet terá uma implementação desses três métodos e se essa subclasse for
declarada como abstrata, então esses métodos podem ser implementados mais abaixo na
hierarquia. A Tabela 3.6 detalha a classe Javax.microedition.midlet.MIDlet.
Método Descrição
Comunicação do gerenciador de aplicativos com a MIDlet
abstract void destroyApp(boolean unconditional) A MIDlet está para ser desligada.
abstract void pauseApp() A MIDlet está para ser colocada no estado
de pausa.
abstract void startApp() A MIDlet foi colocada no estado ativo.
Comunicação da MIDlet com o gerenciador de aplicativos
final void notifyDestroyed() A MIDlet está pedindo para ser desligada.
final void notifyPaused() A MIDlet está pedindo para fazer uma
pausa.
final void resumeRequest() A MIDlet está pedindo para se tornar ativa
(após uma pausa).
Pedido de atributo da MIDlet para o gerenciador de aplicativos
final String getAppPropriety(String key) Obtém atributos dos arquivos JAR e/ou
JAD.
Cada MIDlet tem uma referência para UM objeto Display. Esse objeto pode recuperar
72
informações sobre a tela atual e inclui métodos para solicitar que elementos de tela (Form,
TextBox, etc) sejam exibidos, ou seja, esse objeto funciona como um gerenciador de tela que
controla o que é exibido e quando.
Embora haja apenas um objeto Display por MIDlet, dentro de uma MIDlet podem existir
muitos elementos de tela que podem ser exibidos, tais como Forms, TextBoxes, ChoiceGroups,
etc. Esses elementos de tela também são objetos, cada um deles é uma subclasse de Displayable,
de modo que existem métodos para alternar entre esses vários componentes que podem ser
exibidos. A Tabela 3.7 detalha a classes Display (Javax.microedition.lcdui.Display).
Método Descrição
static Display getDisplay(MIDlet m) Obtém o objeto Display dessa MIDlet.
Displayable getCurrent() Obtém o objeto Displayable corrente.
void setCurrent(Alert alert, Displayable Mostra um alerta, seguido do objeto
nextDisplayable) Displayable especificado.
void setCurrent(Displayable nextDisplayable) Mostra um novo objeto Displayable.
boolean isColor() A tela do dispositivo é colorida?
int numColors() Quantas cores (ou tons de cinza) estão
disponíveis?
void callSerially(Runnable r) Pede para que um objetivo executável seja
chamado após a repintura.
Como foi mencionado, um objeto Display pode exibir qualquer número de objetos
Displayable. O MIDIP inclui duas subclasses abstratas de Displayable: Screen e Canvas. Os
objetos da subclasse Screen (TextBox, List, Form e Alert) são todos componentes de alto nível da
interface com o usuários, sua implementação e apresentação no dispositivo são manipuladas pelo
programador. O objeto Canvas é usado para elementos gráficos personalizados e tratamento de
eventos de baixo nível, por esse motivo o Canvas é mais utilizado ao se escrever jogos. A
hierarquia da classe Displayable é mostrada na Figura 3.39 abaixo.
73
Figura 3.39 - Hierarquia da classe Display.
Conforme mostrado na Figura 3.39 pode-se observar que duas classes principais
compõem a API de baixo nível, Canvas e Graphics. A classe Canvas forma a tela de fundo, a
idéia por trás é similar a tela de desenho de um artista, essa tela tem uma altura e largura
específicas, e nela é desenhado o que o usuário final verá. O desenho é feito na tela com um
objeto Graphics uma vez que essa classe possui métodos para desenhar linhas, arcos, retângulos e
texto assim como especificar cor e fonte.
Ao se desenhar texto, além de se fornecer o objeto String a ser exibido, também deve se
especificar uma localização x e y. Dado que o sistema de coordenadas começa no canto superior
75
esquerdo da tela, seria razoável supor que esse valor x e y fosse um deslocamento a partir dessa
posição. [16]
Entretanto, para dar maior flexibilidade e tornar mais fácil o alinhamento do texto foi
introduzido o conceito de ponto de âncora. Os pontos de âncora são definidos em pares
horizontais e verticais, assim como as coordenadas x e y. A Tabela 3.9 mostra os valores
possíveis para esses pontos de âncora.
76
CAPÍTULO 4 – IMPLEMENTAÇÃO
O ChaTooth foi o aplicativo desenvolvido para estabelecer uma comunicação entre dois
celulares e permitir a troca de mensagens (chat) entre esses equipamentos. O pacote chatooth foi
construído baseado em exemplos contidos no Java Developers Journal, Documentação da API,
informações retiradas do site da SUN e da referência [16].
O aplicativo foi desenvolvido visando uma arquitetura cliente/servidor, onde o primeiro
dispositivo a executar o software torna-se automaticamente o servidor de chat e todos os
dispositivos que se conectarem após serão os clientes. Alguns termos foram usados no
desenvolvimento do projeto, para facilitar a compreensão, foram eles:
• Dispositivo servidor: Dispositivo que primeiro inicializa o software;
• Cliente: Todos os dispositivos que se conectarem ao servidor;
• Parceiro: Dispositivos localizados na área de abrangência do rádio Bluetooth (na
mesma piconet).
• Serviço servidor: Instância do programa ChaTooth sendo executada no
dispositivo servidor a fim de aguardar conexões dos clientes e manipular os
eventos.
Conforme mostrado anteriormente, para instalação de aplicativos em telefones celulares
da nokia é necessário que esses dispositivos estejam previamente pareados. No caso do serviço
ChaTooth a busca é feita de modo a localizar todos os dispositivos na mesma piconet,
independentemente do fato de eles se encontrarem pareados ou não, dessa forma não existe a
obrigatoriedade do pareamento prévio de dispositivos para uso do ChaTooth.
77
A construção do pacote ChaTooth foi realizada em dez arquivos Java de código fonte,
cujo código fonte completo está disponibilizado como anexo deste trabalho. A opção por esse
desmembramento em blocos foi feita a fim de facilitar a compreensão do código, as rotinas
implementadas em cada arquivo estão descritas na Tabela 4.1.
Arquivo Descrição
AUXEventos Configuração de constantes de eventos.
ChaTooth Pacote principal, principais funções:
• Manipular eventos de rede;
• Manipular comandos do usuário;
• Escrita na tela;
Empacotador Prepara a formatação da mensagem antes de enviar por meio do Bluetooth.
EntraUI Interface com o usuário para digitação da mensagem a ser enviada.
Kernel Interface de rede do chat, principais funções:
• Busca por dispositivos próximos;
• Serviço de servidor de chat;
• Busca por servidores próximos;
• Manipular e estabelecer conexões entre os dispositivos.
MensagemUI Desenho da tela
TX_Thread Envio de dados
RX_Thread Recebimento de dados
Parceiro Manipula informações dos parceiros.
NomeUI Interface com o usuário para digitação do nome a ser usado no chat.
78
Figura 4.1 - Projeto ChaTooth, fluxograma de funcionamento.
4.2 PC-PC
Esta aplicação foi idealizada para servir de base ao próximo passo deste projeto, que é a
comunicação PC – Celular. Como apresentado anteriormente, a comunicação Celular – Celular já
foi estudada e implementada, e se faz necessário conhecer as particularidades deste novo
79
ambiente de desenvolvimento até agora não abordado neste projeto, que é o Bluetooth em PC’s.
4.2.1 Recursos
4.2.2 A conexão
O primeiro passo para desenvolver esta aplicação, é definir a forma de busca e conexão
dos dispositivos. Neste projeto, foi definido que serão dois tipos de aplicativos, um servidor e um
cliente, de forma a simplificar a construção de cada um.
Para o servidor, definimos o endereço UUID e uma classe de serviço para o dispositivo.
Estas informações serão utilizadas para identificar o dispositivo local e os serviços que estão
disponíveis, em caso de dispositivos remotos realizarem uma busca. Como se trata de um
servidor, o método setDeviceServiceClasses() da interface ServiceRecord é utilizado para
permitir o envio de informações detalhadas aos clientes remotos, informando com detalhes os
80
serviços que estão rodando no servidor e seus parâmetros de configuração.
Para realizar a conexão, o método acceptAndOpen() da interface
L2CAPConnectionNotifier é chamado. Com esta chamada, o servidor aguardará até que o cliente
conecte, retornando a conexão já estabelecida.
A partir deste ponto a comunicação está estabelecida, e pode-se desenvolver o aplicativo
com base nesta conexão.
Porém, este processo descrito acima não é idêntico no aplicativo cliente, é necessário
definir o funcionamento do cliente de acordo com o processo apresentado para o servidor.
No cliente, primeiramente precisamos definir a forma de busca, que será o
startInquiry() da classe DiscoveryAgent. Esta forma de busca atualiza a lista de dispositivos
4.2.3 O Chat
82
Figura 4.3 - Aplicativo PC-PC, tela cliente
4.3 PC-Celular
Este projeto é uma junção dos dois projetos anteriores, onde apresentamos a
comunicação entre celulares (utilizando o ambiente J2ME), e entre computadores pessoais
(utilizando o ambiente J2SE), ambos utilizando o rádio Bluetooth como meio de transmissão de
dados.
Com esta nova implementação, o objetivo é estabelecer uma comunicação ponto-a-ponto
desenvolvida em linguagem Java (nos ambientes J2ME e J2SE) entre dois dispositivos utilizando
tecnologia Bluetooth de comunicação sem fio.
Neste projeto são utilizados um dispositivo móvel com suporte ao perfil MIDP e a
Bluetooth, e um computador pessoal, utilizando um Dongle USB/Bluetooth.
83
um servidor e um cliente, onde neste caso, o dispositivo em que cada tipo de aplicativo for ser
executado fará diferença. Haja vista esta necessidade, foi definido o dispositivo PC para suportar
o servidor, e o dispositivo móvel como ambiente de execução do cliente.
O servidor deste Chat é um aplicativo Java desenvolvido em J2SE, utilizando a SDK
1.5.0. A função deste aplicativo é prover o ambiente de conexão Bluetooth para aguardar a
conexão do cliente, e então rodar um comunicação ponto-a-ponto com troca de mensagens de
texto. O servidor do projeto de comunicação PC – PC atende a todas estas características,
portanto será mantido inalterado para ser utilizado também neste projeto, comprovando a
portabilidade do aplicativo.
O aplicativo cliente é desenvolvido em J2ME, e roda em um dispositivo portátil com
suporte ao perfil MIDP e Bluetooth, no caso um celular. Este celular irá estabelecer uma conexão
com um servidor de serviço específico – o PC – e então rodar um aplicativo de comunicação via
mensagens de texto – o Chat.
O estabelecimento da conexão se dá de forma semelhante ao projeto PC-PC, o que é
demonstrando a seguir no fluxograma e no detalhamento do funcionamento dos dois aplicativos
envolvidos neste projeto.
4.3.2 Funcionamento
85
Figura 4.4 - Aplicativo PC-Celular, fluxograma de funcionamento servidor.
86
Figura 4.5 - Aplicativo PC-Celular, fluxograma de funcionamento cliente.
O aplicativo cliente, para iniciar sua operação, deve ser construído e carregado,
chamando para isso o método StartApp(). Depois de carregado, uma nova classe é carregada, a
BLUElet.Esta classe é a implementação da biblioteca BlueCove para MIDP, necessária para a
87
comunicação com um dispositivo remoto que esteja utilizando a biblioteca BlueCove. O
BLUElet é um aplicativo MIDP, com todas as características e atributos de um MIDlet.
Através da chamada do método StartApp() do BLUElet, o aplicativo inicia o rádio do
dispositivo local, realizando uma busca em seu raio de alcance pelos dispositivos Bluetooth
disponíveis. Esta busca é realizada através do método startInquiry(). Com esta busca, é
exibida uma lista para que o usuário possa selecionar o dispositivo em que está rodando o
servidor. Caso a lista esteja vazia ou o usuário local não estiver satisfeito com a lista exibida,
poderá solicitar uma nova busca, a fim de atualizar a lista de dispositivos próximos. A classe que
disponibiliza esta lista ao usuário no BLUElet é a RemoteDeviceUI, que a obtêm do próprio
BLUElet.
Uma vez que o usuário tenha selecionado o dispositivo desejado, o MIDlet irá verificar
se o dispositivo remoto possui o serviço desejado disponível, neste caso a busca é pelo aplicativo
servidor. Esta busca é realizada através do método searchServices() da classe
DiscoveryAgent, sendo chamada pelo BLUElet. Caso a busca seja bem sucedida, o aplicativo
cliente irá estabelecer a conexão com o servidor, caso contrário exibirá uma exceção informando
a falha ao usuário e finalizará o MIDlet.
Com a conexão estabelecida, o processo de comunicação através de mensagens é
iniciado. O MIDlet, como cliente, detêm o direito de escrita para a primeira mensagem. Por se
tratar de um aplicativo MIDP, a forma de entrada de texto é diferente do processo do cliente do
projeto anterior. Nesta tarefa, a classe EntraUI é invocada, através da thread do Chat, que chama
para exibição em tela o objeto digita, que é filho de uma classe TextBox
(Javax.microedition.lcdui.TextBox). Esta classe é a responsável pela criação da tela de entrada de
dados pelo usuário local, que a partir dela irá encaminhar as mensagens para que a thread as
envie ao servidor remoto.
O método de envio é semelhante ao do aplicativo cliente do projeto PC – PC, utilizando
a classe DataOutputStream. O recebimento também é idêntico ao processo citado no projeto
anterior, utilizando a classe DataInputStream.
A diferença neste projeto no que diz respeito ao envio e recebimento, é a possibilidade
de se trabalhar com os objetos das duas classes simultaneamente, o que não foi possível no caso
do J2SE em modo console. No projeto anterior, assim como no servidor deste projeto, para se
utilizar um objeto da classe DataInputStream é necessário que os objetos da classe
88
DataOutputStream sejam finalizados, e vice-versa, o que faz o programa ficar alternando entre
objetos quando há um ‘cambio’ no Chat.
Uma outra diferença, porém na área gráfica, é o modo de exibição das mensagens. O
MIDlet desenvolvido utiliza a classe MensagemUI, com herança da classe Canvas
(Javax.microedition.lcdui.Canvas) para exibição das mensagens do Chat, assim como no
primeiro projeto apresentado. A Canvas oferece suporte aos comandos de navegação e suporte a
fontes e telas gráficas mais detalhadas, o que é interessante para a exibição de grande quantidade
de texto. O método chamado para adicionar novas mensagens à tela é o addElement() da classe
MensagemUI construída, seguido de uma chamada ao método repaint() da mesma Canvas.
Com estas definições e implementações, o aplicativo de comunicação por mensagens
instantâneas entre o PC e o celular foi desenvolvido e testado, comprovando a compatibilidade
das linguagens e tecnologias utilizadas. O Chat, apesar de simples, comprova a confiabilidade da
comunicação, abrindo um leque de oportunidades a serem exploradas através da conexão
demonstrada neste projeto.
89
CAPÍTULO 5 – CONCLUSÃO
90
sincronização de dados entre dispositivos distintos, aplicativos rodando em redes pessoais móveis
etc. As possibilidades são e serão cada vez maiores, a medida que a tecnologia e a informação se
tornam cada vez mais acessíveis.
Com a utilização da biblioteca BlueCove, este trabalho demonstrou também uma
necessidade de integração de bibliotecas dos sistemas operacionais para permitir o acesso aos
dispositivos Dongle, que hoje necessitam de uma biblioteca adicional para que a interface se
torne transparente ao programador.
91
ANEXO 1
Projeto PC-PC
Cliente em J2SE / Console
Client_Main.Java
package cliente;
import Java.io.*;
import Javax.Bluetooth.*;
public Client_Main()
{
instance = this;
}
92
ANEXO 2
Projeto PC-PC
Cliente em J2SE / Console
SPP_Client.Java
package cliente;
import Java.io.*;
import Javax.Bluetooth.*;
import Javax.microedition.io.*;
DataOutputStream out;
DataInputStream in;
String msg = "nada";
String s = "nada";
while
(!((s.toLowerCase()).equals("exit"))&&!((msg.toLowerCase()).equals("exit")))
{
out = con.openDataOutputStream();
while
(!((msg.toLowerCase()).equals("cambio"))&&!((msg.toLowerCase()).equals("exit")
))
{
BufferedReader leitor = new BufferedReader(new
InputStreamReader(System.in));
msg = leitor.readLine();
out.writeUTF( msg );
out.flush();
log("Enviado : '"+msg+"'");
}
if ((msg.toLowerCase()).equals("exit"))
break;
msg = "nada";
out.close();
s = "nada";
in = con.openDataInputStream();
while
(!((s.toLowerCase()).equals("exit"))&&!((s.toLowerCase()).equals("cambio")))
{
93
s = in.readUTF();
log("Recebido : '"+s+"'");
}
if ((s.toLowerCase()).equals("exit"))
break;
else
{
in.close();
log ("Digite uma mensagem:");
}
}
con.close();
} catch (Exception e)
{
e.printStackTrace();
}
}
94
ANEXO 3
Projeto PC-PC
Cliente em J2SE / Console
BLUEletConsole.Java
package cliente;
import Java.util.Vector;
import Javax.Bluetooth.*;
import Java.io.*;
95
public void destroyApp(boolean unconditional)
{
}
devices.removeAllElements();
96
deviceClasses.removeAllElements();
device = LocalDevice.getLocalDevice();
device.setDiscoverable(DiscoveryAgent.GIAC);
agent = device.getDiscoveryAgent();
remotedeviceui.setMsg("[Aguarde...]");
} catch ( BluetoothStateException e )
{
e.printStackTrace();
}
services.removeAllElements();
try
{
agent.searchServices(null,
serviceUUIDs,
remoteDevice,
new Listener() );
}
}
if ( devices.size() == 0 )
{
System.out.println("Nenhum dispositivo Bluetooth encontrado");
remotedeviceui.showui();
} else
{
remotedeviceui.showui();
}
break;
case ID_DEVICE_COMPLETED:
callback.commandAction( COMPLETED, remotedeviceui);
break;
case ID_DEVICE_SELECTED:
callback.commandAction( SELECTED, remotedeviceui);
break;
default:
break;
}
}
}
99
ANEXO 4
Projeto PC-PC
Cliente em J2SE / Console
RemoteDeviceUI.Java
package cliente;
import Javax.Bluetooth.*;
import Java.io.*;
public RemoteDeviceUI()
{
addCommand( "Select" );
addCommand( "Search" );
addCommand( BLUEletConsole.BACK );
setCommandListener( BLUEletConsole.instance );
}
}
public void showui()
{
if (BLUEletConsole.devices.size() > 0)
{
System.out.println("[Found "+BLUEletConsole.devices.size()+" devices,
selected one of the following:");
for (int i = 0; i < BLUEletConsole.devices.size(); i++)
{
try
{
RemoteDevice device = (RemoteDevice)
BLUEletConsole.devices.elementAt(i);
String name = device.getFriendlyName(false);
System.out.println("["+i+"] "+name);
} catch (Exception e)
{
e.printStackTrace();
}
}
100
public void run()
{
try
{
BufferedReader in = new BufferedReader(new
InputStreamReader(System.in));
String s = in.readLine();
selected = Integer.parseInt( s );
if ( listener != null )
listener.commandAction( "Select", RemoteDeviceUI.this);
} catch (Exception e)
{
e.printStackTrace();
}
}
};
t.start();
} else
{
}
}
101
ANEXO 5
Projeto PC-PC
Cliente em J2SE / Console
MessageUI.Java
package cliente;
import Java.util.Vector;
import Java.io.*;
}
}
102
ANEXO 6
Projeto PC-PC
Cliente em J2SE / Console
CommandListener.Java
package cliente;
103
ANEXO 7
Projeto PC-PC e PC-Cel
Servidor em J2SE / Console
Server_Main.Java
package servidor;
import Java.io.*;
import Javax.Bluetooth.*;
104
ANEXO 8
Projeto PC-PC e PC-Cel
Servidor em J2SE / Console
SPP_Server.Java
package servidor;
import Javax.Bluetooth.*;
import Javax.microedition.io.*;
import Java.io.*;
public SPP_Server()
{
}
} catch ( BluetoothStateException e )
{
e.printStackTrace();
}
105
0xFF ) );
rec.setDeviceServiceClasses( SERVICE_TELEPHONY );
} catch (Exception e)
{
e.printStackTrace();
log(e.getClass().getName()+" "+e.getMessage());
}
try {
log("Servidor aguardando por conexao do cliente...");
c = server.acceptAndOpen();
log("Conexao aceita. Recebendo...");
RemoteDevice rdev = RemoteDevice.getRemoteDevice( c );
String s = "nada";
String texto_local = "nada";
DataInputStream in;
DataOutputStream out;
while
(!((texto_local.toLowerCase()).equals("exit"))&&!((s.toLowerCase()).equals("ex
it")))
{
in = c.openDataInputStream();
s = in.readUTF();
log("Recebido: '"+s+"' ");
if ((s.toLowerCase()).equals("exit"))
break;
if ((s.toLowerCase()).equals("cambio"))
{
in.close();
out = c.openDataOutputStream();
log ("Digite uma mensagem:");
while
(!((texto_local.toLowerCase()).equals("exit"))&&!((texto_local.toLowerCase()).
equals("cambio")))
{
BufferedReader leitor = new BufferedReader(new
InputStreamReader(System.in));
texto_local = leitor.readLine();
out.writeUTF( texto_local );
out.flush();
log("Enviado: '"+texto_local+"'");
}
out.close();
if ((texto_local.toLowerCase()).equals("exit"))
break;
texto_local = "nada";
}
}
c.close();
try
{
Server_Main.instance.spp_server.done = true;
if ( Server_Main.instance.spp_server.server != null )
Server_Main.instance.spp_server.server.close();
}
106
catch (IOException ex)
{
}
Server_Main.instance.quitApp();
} catch (Exception e)
{
e.printStackTrace();
Server_Main.alert(e);
}
}
107
ANEXO 9
Projeto PC-Cel
Cliente em J2ME / MIDP
Client_MIDP.Java
package client_MIDP;
import Java.io.*;
import Javax.Bluetooth.*;
import Javax.microedition.lcdui.*;
import Javax.microedition.midlet.*;
public Client_MIDlet()
{
principal = this;
}
108
principal.destroyApp(true);
principal.notifyDestroyed();
principal = null;
}
}
109
ANEXO 10
Projeto PC-Cel
Cliente em J2ME / MIDP
SPP_Client.Java
package client_MIDP;
import Java.io.*;
import Javax.Bluetooth.*;
import Javax.microedition.io.*;
public SPP_Client()
{
}
try
{
StreamConnection con = (StreamConnection) Connector.open( url );
log("Conectado ao Servidor. Digite uma mensagem...");
DataOutputStream out = con.openDataOutputStream();
DataInputStream in = con.openDataInputStream();
String s = "nada";
while
(!((s.toLowerCase()).equals("exit"))&&!((msg.toLowerCase()).equals("exit")))
{
while
(!((msg.toLowerCase()).equals("cambio"))&&!((msg.toLowerCase()).equals("exit")
))
{
Client_MIDlet.display.setCurrent( Client_MIDlet.principal.digita
);
if (Client_MIDlet.principal.flag)
{
if (Client_MIDlet.principal.digita.size() == 0)
Client_MIDlet.principal.digita.setString(" ");
msg = Client_MIDlet.principal.digita.getString();
Client_MIDlet.principal.flag = false;
Client_MIDlet.principal.digita.delete(0,Client_MIDlet.principal.digita.size())
;
out.writeUTF( msg );
out.flush();
log("Enviado : '"+msg+"'");
}
}
Client_MIDlet.display.setCurrent( Client_MIDlet.principal.recarregar
110
);
if ((msg.toLowerCase()).equals("exit"))
{
con.close();
Client_MIDlet.principal.quitApp();
}
msg = "nada";
s = "nada";
while
(!((s.toLowerCase()).equals("exit"))&&!((s.toLowerCase()).equals("cambio")))
{
s = in.readUTF();
log("Recebido : '"+s+"'");
}
if ((s.toLowerCase()).equals("exit"))
{
con.close();
Client_MIDlet.principal.quitApp();
}
}
con.close();
} catch (Exception e)
{
e.printStackTrace();
Client_MIDlet.alert( e, Client_MIDlet.principal.recarregar );
}
111
ANEXO 11
Projeto PC-Cel
Cliente em J2ME / MIDP
BLUElet.Java
package client_MIDP;
import Java.util.*;
import Javax.Bluetooth.*;
import Javax.microedition.lcdui.*;
import Javax.microedition.midlet.*;
display = Display.getDisplay(host);
remotedeviceui = new RemoteDeviceUI();
remotedeviceui.showui();
}
112
public void pauseApp()
{
}
devices.removeAllElements();
deviceClasses.removeAllElements();
113
device = LocalDevice.getLocalDevice();
device.setDiscoverable(DiscoveryAgent.GIAC);
agent = device.getDiscoveryAgent();
} catch ( BluetoothStateException e )
{
e.printStackTrace();
}
try
{
agent.searchServices(null,
serviceUUIDs,
remoteDevice,
new Listener() );
display.callSerially(new Worker(ID_DEVICE_SELECTED));
}
}
if ( devices.size() == 0 )
{
Alert alert = new Alert( "Bluetooth", "Nenhum dispositivo Bluetooth
encontrado", null, AlertType.INFO );
alert.setTimeout(3000);
remotedeviceui.showui();
display.setCurrent( alert, remotedeviceui );
} else
{
remotedeviceui.showui();
display.setCurrent( remotedeviceui );
}
break;
case ID_DEVICE_COMPLETED:
callback.commandAction( COMPLETED, remotedeviceui);
break;
case ID_DEVICE_SELECTED:
callback.commandAction( SELECTED, remotedeviceui);
break;
default:
break;
}
}
}
116
ANEXO 12
Projeto PC-Cel
Cliente em J2ME / MIDP
RemoteDeviceUI.Java
package client_MIDP;
import Javax.microedition.lcdui.*;
import Javax.Bluetooth.*;
} catch (Exception e)
{
e.printStackTrace();
}
}
} else
{
append("[Nao Encontrado]", null);
}
}
}
117
ANEXO 13
Projeto PC-Cel
Cliente em J2ME / MIDP
MensagemUI.Java
package client_MIDP;
import Javax.microedition.lcdui.*;
import Java.util.*;
public MensagemUI()
{
addCommand(new Command("Sair", Command.BACK, 1));
}
if ( f == null )
{
f = Font.getFont( Font.FACE_MONOSPACE, Font.STYLE_PLAIN,
Font.SIZE_SMALL );
w = this.getWidth();
h = this.getHeight();
fh = f.getHeight();
}
int y = fh;
g.translate(-x0, -y0);
118
g.drawString( s, 0, y, Graphics.BASELINE | Graphics.LEFT );
y += fh;
}
119
ANEXO 14
Projeto PC-Cel
Cliente em J2ME / MIDP
EntraUI.Java
package client_MIDP;
import Javax.microedition.lcdui.*;
public EntraUI() {
super("Digite a Mensagem", "", 200, TextField.ANY);
addCommand(new Command("Enviar", Command.SCREEN, 1));
addCommand(new Command("Voltar", Command.SCREEN, 2));
setCommandListener( Client_MIDlet.principal );
}
120
ANEXO 15
Projeto PC-Cel
Cliente em J2ME / MIDP
TelaUI.Java
package client_MIDP;
import Javax.microedition.lcdui.*;
public TelaUI()
{
}
121
ANEXO 16
Projeto Chatooth
Cliente/Servidor em J2ME / MIDP
Chatooth.Java
package chatooth;
import Javax.microedition.midlet.*;
import Javax.microedition.lcdui.*;
import Java.io.*;
public Chatooth()
{
principal = this;
}
tela = Display.getDisplay(this );
122
public void handleAction( String event, Object param1, Object param2 )
{
if ( event.equals( AUXEventos.EVENT_JOIN ) )
{
parceiro endpt = (parceiro) param1;
String msg = endpt.remoteName + " entrou no chat;";
Empacotador packet = new Empacotador(Kernel.SIGNAL_HANDSHAKE,
endpt.remoteName, msg );
mensagem.msgs.addElement( packet );
mensagem.repaint();
btnet.query();
tela.setCurrent( mensagem );
}
}
124
ANEXO 17
Projeto Chatooth
Cliente/Servidor em J2ME / MIDP
NomeUI.Java
package chatooth;
import Javax.microedition.lcdui.*;
TextField text;
public NomeUI()
{
super("Informe seu nome");
addCommand(new Command("Chat", Command.SCREEN, 1));
setCommandListener( Chatooth.principal );
append( new StringItem( "", "Informe um nome e selecione a opcao CHAT." )
);
append( text = new TextField( "Nome", "", 10, TextField.ANY ) );
}
}
125
ANEXO 18
Projeto Chatooth
Cliente/Servidor em J2ME / MIDP
MensagemUI.Java
package chatooth;
import Javax.microedition.lcdui.*;
import Java.util.*;
public MensagemUI()
{
addCommand(new Command("Escrever", Command.SCREEN, 1));
addCommand(new Command("Limpar", Command.SCREEN, 2));
addCommand(new Command("Sair do Chat", Command.SCREEN, 3));
setCommandListener( Chatooth.principal );
}
126
}
}
public void keyPressed( int key )
{
if ( getGameAction( key ) == Canvas.RIGHT )
{
x0+=10;
} else if ( getGameAction( key ) == Canvas.LEFT )
{
x0-=10;
} else if ( getGameAction( key ) == Canvas.UP )
{
y0-=10;
} else if ( getGameAction( key ) == Canvas.DOWN )
{
y0+=10;
}
repaint();
}
127
ANEXO 19
Projeto Chatooth
Cliente/Servidor em J2ME / MIDP
EntraUI.Java
package chatooth;
import Javax.microedition.lcdui.*;
public EntraUI() {
super("Digite a Mensagem", "", 200, TextField.ANY);
addCommand(new Command("Enviar", Command.SCREEN, 1));
addCommand(new Command("Voltar", Command.SCREEN, 2));
setCommandListener( Chatooth.principal );
}
128
ANEXO 20
Projeto Chatooth
Cliente/Servidor em J2ME / MIDP
Kernel.Java
package chatooth;
import Javax.microedition.io.*;
import Javax.Bluetooth.*;
import Java.io.*;
import Java.util.*;
import Javax.Bluetooth.RemoteDevice;
import Javax.Bluetooth.DeviceClass;
import Javax.Bluetooth.ServiceRecord;
public Kernel()
{
}
129
{
try {
this.localName = name;
this.callback = callback;
localDevice = LocalDevice.getLocalDevice();
localDevice.setDiscoverable(DiscoveryAgent.GIAC);
agent = localDevice.getDiscoveryAgent();
}
catch (BluetoothStateException e) {
e.printStackTrace();
}
catch (IOException e) {
e.printStackTrace();
}
}
rec.setDeviceServiceClasses(SERVICE_TELEPHONY);
131
} catch (Exception e)
{
e.printStackTrace();
}
while( !desconecta_todos)
{
try {
Chatooth.principal.log_ui( "", "Pronto para aceitar conexões." );
Chatooth.principal.log_ui( "", "Aguarde..." );
c = server.acceptAndOpen();
dispositivos_proximos.addElement( endpt );
}
catch (IOException e) {
e.printStackTrace();
if (c != null)
try {
c.close();
}
catch (IOException e2) {
}
}
finally {
}
}
}
try
132
{
parceiro endpt = new parceiro(Kernel.this, remoteDevice, null);
vetordebusca.addElement( endpt );
} catch (Exception e)
{
e.printStackTrace();
}
}
} catch (Exception e)
{
e.printStackTrace();
133
}
}
registroparceiro.clear();
synchronized( lock )
{
lock.notifyAll();
}
synchronized( lock )
{
try {
lock.wait();
}
catch (InterruptedException ex) {
}
}
}
catch (BluetoothStateException e) {
e.printStackTrace();
vetordebusca.removeAllElements();
134
ANEXO 21
Projeto Chatooth
Cliente/Servidor em J2ME / MIDP
parceiro.Java
package chatooth;
import Javax.Bluetooth.*;
import Javax.microedition.io.*;
import Java.io.*;
import Java.util.*;
TX_Thread sender;
RX_Thread reader;
String localName;
String remoteName;
AUXEventos callback;
Kernel btnet;
remoteDev = rdev;
try {
remoteName = rdev.getFriendlyName(false);
}
catch (IOException ex) {
remoteName = "Desconhecido";
}
localName = btnet.localName;
callback = btnet.callback;
con = c;
135
}
if ( msgs.size() > 0 )
{
Empacotador s = (Empacotador) msgs.firstElement();
msgs.removeElementAt(0);
return s;
} else
{
return null;
}
}
136
ANEXO 22
Projeto Chatooth
Cliente/Servidor em J2ME / MIDP
Empacotador.Java
package chatooth;
public Empacotador()
{
}
}
137
ANEXO 23
Projeto Chatooth
Cliente/Servidor em J2ME / MIDP
TX_Thread.Java
package chatooth;
import Java.io.*;
public TX_Thread()
{
}
if ( ! endpt.peekString() )
{
synchronized (this) {
this.wait(5000);
}
}
Empacotador s = endpt.getString();
if ( s != null )
{
dataout.writeInt(s.signal);
dataout.writeUTF(s.msg );
dataout.flush();
}
138
dataout.close();
} catch (Exception e)
{
e.printStackTrace();
}
}
}
139
ANEXO 24
Projeto Chatooth
Cliente/Servidor em J2ME / MIDP
RX_Thread.Java
package chatooth;
import Java.io.*;
public RX_Thread() {
}
while ( !done )
{
int signal = datain.readInt();
if ( signal == Kernel.SIGNAL_MESSAGE )
{
String s = datain.readUTF();
Empacotador packet = new Empacotador( Kernel.SIGNAL_MESSAGE,
endpt.remoteName, s );
140
endpt.callback.handleAction( AUXEventos.EVENT_LEAVE, endpt, null );
endpt.btnet.cleanupRemoteparceiro( endpt );
stop();
datain.close();
} catch (Exception e)
{
e.printStackTrace();
}
}
}
141
ANEXO 25
Projeto Chatooth
Cliente/Servidor em J2ME / MIDP
AUXEventos.Java
package chatooth;
142
REFERÊNCIAS BIBLIOGRÁFICAS
[1] TORRES, Gabriel. Redes de computadores: Curso completo. Rio de Janeiro: Axcel
Books, 2001.
[2] MAIA, Roberto M.F. Bluetooth, Promessas de uma nova tecnologia. 2003, 77f.
(Trabalho de conclusão de curso) Curso de sistema de informação. Faculdade
Integrada de Recife.
[5] HAARTSEN, Jaap C. "The Bluetooth Radio System", IEEE Personal Communication.
Fevereiro de 2000.
[11] GUPTA, Vikas, DASS, Avnish e CHAUHAN, Yashraj. Wireless programming with
J2ME – Cracking the code. E-book Editora: Hungry Minds, 2002.
143
[12] WHITE, James; HEMPHILL, David. Java to micro edition – Java in small things. E-
book Editora: Manning Plublication Co.
[14] KAMMANN, Jens. Mobile services over short range communication. Workshop
Commercial Radio Sensors and Communication Techniques, 2001, Austria.
[16] MUCHOW, John W. Core J2ME – Tecnologia & MIDP. São Paulo, Pearson Books,
2004.
144