Desenvolvimento de Aplicativos Móveis com JavaME e Bluetooth®

Prévia do material em texto

Desenvolvimento de Aplicativos Móveis com Bluetooth® 
Utilizando a Plataforma Java Micro Edition
Índice
1. Introdução
1.1. Desafios no Desenvolvimento de Aplicativos para Celular
1.2. O que é Java Micro Edition
2. Programando em JavaME
2.1. Fluxo de Telas
2.1.1.MIDlet Visual
2.1.2.Formulário
2.1.3.Lista
2.1.4.Canvas
2.2. Comandos
2.2.1. Adicionando Comandos
2.2.2. Personalizando o Comportamento de um Comando
3. Aplicações com Bluetooth®
3.1. Estabelecendo uma Conexão
3.1.1. Procurando por Dispositivos
3.1.2. Procurando por Serviços
3.1.3. Instanciando a Conexão
3.1.4. Envio e Recebimento de Dados
4. Instalando o Aplicativo.
1. Introdução
Nos dias de hoje, a demanda por inovações na área de aplicações para dispositivos móveis vem 
crescendo a cada dia, e isso se deve à grande quantidade de novidades que vêm sendo apresentadas aos 
consumidores nas lojas de artigos eletrônicos. Os celulares e smartphones fabricados na atualidade são 
caracterizados pela grande variedade de recursos de hardware que possuem, e isso aumenta as 
possibilidades de desenvolvimento de aplicativos para os mesmos.
Tendo como objetivo níveis ótimos de aproveitamento de tais funcionalidades encontradas nos 
gadgets eletrônicos do mundo moderno, diversas ferramentas têm sido criadas para que desenvolvedores 
interessados em inovar possam criar novas soluções em software para dispositivos móveis de maneira 
descomplicada.
Esta apostila terá como foco apresentar duas ferramentas recentes que têm sido muito úteis na 
modelagem de aplicativos móveis: a plataforma de desenvolvimento Java Micro Edition, e a tecnologia 
Bluetooth®.
1.1. Desafios no Desenvolvimento de Aplicativos para Celular
Um dispositivo móvel, como um celular ou smartphone, não possui as mesmas características de 
um computador convencional, necessitando assim um tipo de estrutura especial para seus aplicativos.
No projeto de um sistema embarcado, devem-se levar em consideração as particularidades na 
estrutura física do aparelho no qual ele será instalado. A arquitetura de um celular comum objetiva a 
portabilidade física do mesmo, o que impede que o mesmo se beneficie de recursos como:
- Cursor movido por periférico de rastreamento vetorial.
- Múltiplos processadores de alto desempenho
- Alta disponibilidade de memória volátil.
- Alta capacidade de armazenamento secundário de dados.
- Tela de exibição grande e de alta qualidade.
Tendo em vista tais privações de hardware, algumas soluções devem ser desenvolvidas pelo 
programador para que a execução do aplicativo seja eficiente, ágil e intuitiva para o usuário.
Ao invés de dirigir um cursor às opções da janela de exibição atual do programa, o usuário deve ser 
capaz de navegar entre as opções utilizando as setas, ou no caso dos smartphones, acessar as opções 
através de botões que respondam ao toque na tela.
Devido ao pequeno espaço de exibição fornecido pela tela dos celulares de tamanho convencional 
(entre 2.5 e 3 polegadas), a interface de exibição do software não consegue comportar muitos recursos 
visuais simultaneamente de maneira eficiente. Isso requer que o desenvolvedor seja minimalista na hora de 
criar sua interface, de modo que saiba associar elegância e funcionalidade sem que a tela de exibição do 
aplicativo seja poluída com informações, botões ou objetos visuais em excesso.
Finalmente, além das dificuldades no desenvolvimento da interface e controle de execução para 
seus sistemas, os dispositivos móveis, em geral, têm disponibilidade limitada de processamento e também 
de armazenamento, tanto primário quanto secundário. Isso gera mais uma barreira a ser transposta nos 
casos onde o aplicativo possui funcionalidades muito complexas ou de alto custo computacional, obrigando 
o programador a ser cauteloso quanto ao uso de estruturas de dados muito custosas ou algoritmos com alto 
custo de processamento (algoritmos de busca com possibilidade de explosão combinacional, procedimentos 
recursivos, etc).
1.2. O que é Java Micro Edition
O JavaME (Java Micro Edition) é um ambiente de programação para desenvolvimento de aplicativos 
móveis desenvolvido pela Oracle, e contém ferramentas simples e eficientes para a criação de soluções 
para celulares e outros dispositivos móveis. Ferramentas robustas, bibliotecas completas contendo métodos 
e classes para todos os fins, e a agregação de novos plug-ins e bibliotecas, são algumas razões pelas quais 
o ambiente têm se tornado bastante popular na área de desenvolvimento de sistemas embarcados.
A plataforma Netbeans comporta com eficiência o JavaME, e servirá como referência para as 
demonstrações contidas nesta apostila.
Os links para download gratuito das ferramentas mencionadas nessa seção podem ser encontradas 
nos links abaixo:
Netbeans IDE 7.0:
http://netbeans.org
Java Micro Edition SDK 3.0:
http://www.oracle.com/technetwork/java/javame/index.html
2. Programando em JavaME
Como visto anteriormente, programar em Java para dispositivos móveis se torna uma tarefa fácil 
quando se tem as ferramentas certas para alcançar os objetivos em um projeto. Um aplicativo para celular 
possui três elementos chave a serem avaliados na hora de ser projetado:
- Qual a sequência das telas a serem exibidas.
- Qual a forma das telas do aplicativo.
- De que maneira o usuário será capaz de navegar pelas funções do aplicativo.
As próximas duas subseções têm como objetivo apresentar como as duas entidades mais 
importantes na criação de um aplicativo são representadas no JavaME: a tela, responsável por apresentar 
todas as informações ao usuário, e o comando, encarregado de permitir ou não, que o usuário tome alguma 
atitude enquanto usa o aplicativo.
2.1. Fluxo de Telas
Para que as funcionalidades sejam apresentadas ao usuário, o JavaME traz consigo uma série de 
classes pré-modeladas primitivas, cada uma com sua finalidade e também suas limitações.
Com um pouco de criatividade é possível associar tais classes de modo a transpor tais limitações, 
permitindo que o aplicativo se torne elegante e funcional, sem que o desenvolvedor precise elaborar novas 
classes e métodos de exibição de tela complexos.
As classes aqui apresentadas são derivadas da classe Displayable, ou seja, toda instância das 
classes apresentadas nas próximas subseções pode ser exibida na tela através do método 
switchDisplayable, que é gerado automaticamente quando criado um novo MIDlet Visual.
2.1.1. MIDlet Visual
Como em todo sistema, os aplicativos embarcados também necessitam de uma classe principal, 
que determina quais e de que forma os procedimentos serão executados.
A classe Visual MIDlet faz a função de “painel de edição” em um aplicativo feito no ambiente 
JavaME, e é nela em que serão adicionados, sincronizados e editadas as telas, funções e comandos do 
aplicativo.
Como ilustrado na figura 1, o ambiente Netbeans possui quatro abas de edição para um Visual 
MIDlet:
1) Código-Fonte: Edição do aplicativo em nível de código.
2) Tela: Manipulação visual de alguma tela presente no aplicativo. Mostra uma prévia do resultado 
final da tela sendo editada.
3) Fluxo: Organização da forma em que serão exibidas as diferentes telas do aplicativo.
4) Analisador: Reporta inconsistências e avalia a funcionalidade da tela em edição.
Figura 1 – Abas de edição para Visual MIDlet no Netbeans.
A criação e edição de um aplicativo se torna muito simples dessa forma, pois a interface de edição é 
descomplicada e permite que o desenvolvedor organize sua aplicação de maneira personalizada.
2.1.2. Formulário
O formulário de texto, contido no pacote javax.microedition.lcdui e identificada como Form, 
é a classe de tela mais simples que pode ser encontrada no ambiente Java Micro Edition. Como a maioria 
das classes de exibição básicasdo mesmo pacote, não é possível arrastar botões, caixas de seleção, listas 
de opção e etc. em sua estrutura, isso só é possível de ser feito com o uso de outras ferramentas mais 
complexas que não entram no escopo desta apostila.
O método append da classe Form permite que tanto texto quanto imagens sejam adicionadas a um 
formulário. A figura 2 ilustra como ambos podem ser feitos.
Figura 2 – Exemplo do uso do método append da classe Form.
Para fins de navegação em tela, o método append também adiciona objetos da classe Item no 
formulário. Em um formulário, o item tem a função de indexar um elemento e assim endereçá-lo quando 
necessário (muito útil na criação de menus).
2.1.3. Lista
A classe List é uma solução excelente quando o programador deseja criar uma lista linear de itens 
selecionáveis na tela. É possível a edição da fonte de exibição, e também a adição de um ícone na lateral 
esquerda de cada item da lista, tudo à escolha do desenvolvedor.
O exemplo da figura 3 mostra como é simples personalizar uma lista de dois itens, de modo que 
cada um tenha seu próprio design.
Figura 3 – Exemplo de lista personalizada criada a partir da classe List.
O método append anexa um novo item com ícone à lista, enquanto setFont determina qual será a 
formatação do texto de exibição do item. É possível também alterar o aspecto de um item durante a 
execução, com a função set, que usa como parâmetro o índice do item a ser modificado, e os novos nome 
e imagem do item.
Durante a execução do aplicativo, o usuário será capaz de navegar pelos itens, e o item 
selecionado pode ser endereçado através do método getSelectedIndex da classe List.
2.1.4. Canvas
Suponha que o desenvolvedor do aplicativo deseje criar uma tela onde cada tecla pressionada pelo 
usuário tenha um efeito diferente no contexto da aplicação, como isso pode ser feito? Através da classe 
Canvas, destinada à modelagem de jogos no JavaME.
A classe Canvas tem uma função que classes básicas como Form e List não suportam, que é o 
suporte à detecção de eventos do teclado.
Para o aproveitamento integral das funcionalidades da classe, o desenvolvedor deverá criar sua 
própria classe e usar a herança, permitindo que os métodos do Canvas sejam sobrescritos. Feita a 
herança, o desenvolvedor terá controle das ações que o usuário tomar enquanto o Canvas estiver sendo 
exibido (pressionar botão, segurar botão, soltar botão, apertar repetidamente alguma tecla, etc).
A exibição em tela desta classe se dá de uma maneira diferenciada. Tanto no formulário quanto na 
lista, a adição de itens na tela era feita através do método append, já no Canvas, todos os elementos a 
serem exibidos deverão ser desenhados em tela através do método paint. Isto requer certa habilidade do 
desenvolvedor na hora de organizar e representar os objetos em tela, porém dá maior liberdade de criação, 
pois quase qualquer forma pode ser desenhada com o uso dos métodos básicos de desenho da classe 
Graphics. A figura 4 mostra um exemplo do que pode ser desenhado em um Canvas com poucas linhas 
de código.
Figura 4 – Exemplo de desenho simples exibido em um Canvas.
Para ter controle sobre os eventos de tecla, basta sobrescrever os métodos de detecção e 
tratamento de eventos abstratos contidos no Canvas. Dois dos principais métodos e suas respectivas 
finalidades são ilustrados na figura 5.
Figura 5 – Exemplos de uso das principais funções da classe Canvas.
O parâmetro de valor inteiro keyCode presente nos métodos keyPressed e keyReleased é 
referente a qual tecla foi acionada pelo usuário, e o Canvas possui endereçamento de todas as teclas 
presentes em teclados comuns de celular.
Outros eventos mais específicos também são identificados pela interface, e possuem os mesmos 
parâmetros de keyPressed e keyReleased.
2.2. Comandos
Comandos são aqueles que determinam quais ações estão disponíveis ao usuário em cada tela 
existente no aplicativo. São representados pela classe Command no JavaME, e suas instâncias são 
“encaixadas” na presente tela, dando uma nova funcionalidade à mesma (formulário, lista, canvas ou 
qualquer outra presente nas bibliotecas da plataforma).
2.2.1. Adicionando Comandos
Quando se programa utilizando o ambiente Netbeans, a aba “fluxo” aparece na tela de edição do 
seu MIDlet, e é nela que será feito todo o gerenciamento de sequência de exibição de telas do aplicativo.
Para adicionar uma tela basta arrastá-la da lista de objetos suportados pela plataforma, e então 
assimilar algum comando de outra tela à sua exibição, de modo que, quando tal comando for acionado, a 
tela atual do aplicativo será atualizada para o objeto de tela recém-criado. O aplicativo ilustrado na figura 6 
tem duas telas: um formulário, que aparece logo quando o aplicativo é iniciado, e uma lista, que é mostrada 
em tela quando o comando “Sair” do formulário for acionado.
Figura 6 – Exemplo de fluxo de telas em um aplicativo.
Da mesma forma que uma tela pode ser colocada no plano de fluxo, um comando pode ser 
colocado em uma tela. Basta usar o mesmo método de “arraste” do tipo de comando escolhido para a tela 
desejada.
Quando adicionado a uma tela, o comando será listado na parte inferior da interface, e então pode 
ser acessado pelo usuário através das teclas padrão do teclado de seu dispositivo móvel. A figura 7 mostra 
qual o aspecto resultante da adição de dois comandos em um formulário.
Figura 7 – Aspecto resultante de um formulário com dois comandos.
2.2.2. Personalizando o Comportamento de um Comando
Uma vez adicionados, os comandos podem ser editados para que realizem algum procedimento 
quando acionados pelo usuário. Para editar o comportamento de um comando, basta ir à parte de código do 
MIDlet que detecta o acionamento do comando, e adicionar as linhas de códigos necessárias.
Os MIDlets, por padrão, têm adicionados a sua estrutura a interface CommandListener, que tem 
por função principal adicionar o método commandAction para a classe. A função commandAction recebe 
por parâmetro uma tela e um comando, e cria assim uma cadeia do tipo “ if-else” onde podem ser escritas as 
funções de cada comando contido em cada tela da aplicação.
Para trocar a tela atual, a classe MIDlet possui o método switchDisplayable. Como exemplo 
da associação da cadeia “if-else” com o método switchDisplayable, podemos usar o caso de exibição 
em tela do Canvas, que deve ser feita manualmente.
Para exibir um Canvas, os seguintes passos devem ser seguidos:
1) Instanciar o Canvas dentro do MIDlet, adicionando todos os comandos do mesmo através do 
método addCommand.
2) Definir qual tela, e qual comando da mesma exibirá o Canvas.
3) Adicionar a função switchDisplayable no final da função que exibirá o Canvas, dentro da 
cadeia “if-else” da função commandAction do MIDlet principal.
4) Extender a classe Canvas para a interface CommandListener no cabeçalho.
5) Associar o Canvas como sendo o próprio CommandListener no construtor através da função 
setCommandListener da própria classe Canvas (exemplo: 
“this.setCommandListener(this);”).
6) Adicionar na cadeia “if-else” os casos de uso dos comandos do Canvas. 
A figura 8 ilustra o resultado em código de um caso onde, o comando “Trocar” do formulário de 
nome “MeuFormulario” exibe o Canvas na tela.
Figura 8 – Exemplo de edição de comandos em nível de código.
Da mesma forma que a troca de telas é feita, qualquer outra função pode ser associada a um 
comando, basta editar seu comportamento na cadeia “if-else” em CommandAction da maneira desejada.
3. Aplicações com Bluetooth®
O protocolo Bluetooth® de comunicação tem se popularizado bastante devido à sua grande 
aplicação na conexão sem fio entre dispositivos, e é bastante utilizado hoje em dia principalmentena 
transferência de pequenas quantidades de dados entre celulares, smartphones e computadores.
Sua estrutura de conexão é simples, e por causa disso se torna uma ferramenta muito útil no 
desenvolvimento de aplicações que demandem a troca de dados, porém nem sempre têm acesso à internet 
para fazê-lo.
O JavaME possui bibliotecas que simplificam a criação dos processos de busca, conexão e 
transferência de dados, porém o emulador da plataforma não permite que a conexão seja efetivamente 
testada no computador, necessitando assim que o aplicativo seja instalado, após a compilação, em algum 
dispositivo com suporte à conexão Bluetooth® para que seja devidamente testado.
3.1. Estabelecendo uma Conexão
Uma conexão via protocolo Bluetooth® entre dois dispositivos deve ser feita por etapas, e requer 
que saibam algumas informações sobre os dispositivos a serem conectados. Primeiramente há de se obter 
as seguintes informações sobre os dispositivos que serão conectados:
1) Quais as especificações de segurança de conexão requeridas (se necessita ou não de 
criptografia ou autenticação).
2) Quais os serviços de conexão fornecidos.
A conexão via Bluetooth® pode ser estabelecida via diferentes protocolos, cada um tendo uma 
função específica. Alguns dos principais protocolos de comunicação possíveis são:
• RFCOMM
• OBEX
• FTP
• HTTP
• L2CAP
As propriedades de cada protocolo não serão discutidas nesta apostila, porém as especificações de 
cada um podem ser encontradas em livros e também na internet.
Existem várias funções que podem ser executadas via Bluetooth®, porém cada dispositivo tem sua 
lista específica de serviços disponíveis. Alguns exemplos de serviços são:
• Conexão via Porta Serial
• Conexão do tipo Dial-Up
• Transferência de Objeto via OPP (Object Push Profile)
• Transferência de Arquivo via FTP (File Transfer Profile)
• Serviço de Fax
• Interpretação de Faixas de Áudio via A2DP (Advanced Audio Distribution Profile)
• Impressão de Arquivos via BPP (Basic Printing Profile)
Os serviços suportados pelo dispositivo são determinados pela arquitetura de hardware e pelo 
sistema operacional usado, o que dificulta bastante a adição de um serviço ao mesmo.O pacote Bluecove 
também se limita a apenas alguns serviços oferecidos pelo protocolo Bluetooth, sendo eles:
• SDAP
• RFCOMM
• L2CAP
• OBEX
As classes e métodos utilizados nos exemplos são do pacote Bluecove, que pode ser baixado 
gratuitamente em http://bluecove.org e deve ser adicionado às bibliotecas do projeto em 
desenvolvimento.
Nos próximos capítulos serão descritos todos os passos necessários para se estabelecer uma 
conexão básica via Bluetooth® usando o Bluecove no JavaME. Para isso também é necessário que se 
saiba quais os padrões de números assimilados da tecnologia Bluetooth®, e os mesmos podem ser 
encontrados em http://www.Bluetooth.org. 
3.1.1. Procurando por Dispositivos
 
Escolher um dispositivo para se conectar é a primeira etapa para a criação do link Bluetooth®. A 
maneira mais simples de fazê-lo é criando uma lista de dispositivos ao alcance, permitindo assim que o 
usuário do aplicativo escolha com qual deseja se conectar.
É possível fazer a busca de dispositivos utilizando apenas quatro classes da biblioteca Bluecove:
• LocalDevice: Representa o dispositivo móvel que hospeda o aplicativo. Guarda todas as 
informações referentes ao dispositivo local.
• RemoteDevice: Representa um dispositivo móvel remoto. Guarda todas as informações de 
identificação do dispositivo externo.
• DiscoveryAgent: Agente de busca. Possui todos os métodos necessários para que o 
procedimento de busca possa ser realizado.
• DiscoveryListener: Auxilia no processo de armazenamento dos dispositivos encontrados. É 
uma interface Java que deve ter seus métodos sobrescritos.
A figura 9 mostra como a chamada do procedimento de busca pode ser feita.
Figura 9 – Procedimento de busca de dispositivos.
O agente da classe DiscoveryAgent pode, através dos métodos startInquiry e 
cancelInquiry, controlar o procedimento de busca de dispositivos.
Quando iniciada a busca, o objeto da classe DiscoveryListener é o responsável por fazer o 
armazenamento dos dispositivos encontrados. Quando encontrado um dispositivo com Bluetooth® ligado ao 
alcance, o método deviceDiscovered é acionado, que por sua vez deve ser capaz de armazenar em 
uma lista as informações do RemoteDevice que foi reconhecido. Um exemplo de implementação da classe 
auxiliar é ilustrado na figura 10.
Figura 10 – Exemplo de implementação da classe DiscoveryListener.
Uma vez terminada a busca, a lista de dispositivos encontrados já pode ser acessada para que a 
listagem em tela dos mesmos possa ser feita.
3.1.2. Procurando por Serviços
Antes da conexão ser criada, há de se saber que tipo de serviço será requisitado do dispositivo 
escolhido. Como visto anteriormente, existe uma grande variedade de serviços suportados pela tecnologia 
Bluetooth®, porém cada dispositivo diferente dá suporte a apenas uma porção específica destes serviços.
Cada serviço é identificado por um UUID (Universally Unique Identifier), um valor fixado pelos 
padrões da tecnologia Bluetooth® que pode ser encontrado em http://www.Bluetooth.org. A busca por 
serviços tem como função detectar quais serviços são suportados pelo dispositivo alvo, e então fornecer 
uma URL de conexão para cada serviço disponível.
Assim como a busca por dispositivos, a busca por serviços é muito simples de ser feita. Na figura 11 
pode ser observado que, a única diferença significativa entre a busca de dispositivos e serviços é o método 
chamado pelo agente da classe DiscoveryAgent.
Figura 11 – Exemplo de busca por serviços.
3.1.3. Instanciando a Conexão
Uma vez conhecidos os serviços disponibilizados pelo dispositivo escolhido, já é possível a criação 
da conexão. Para cada serviço encontrado disponível no RemoteDevice de destino existe uma URL de 
conexão, e basta instanciar um objeto do tipo Connection para que a conexão seja feita e a troca de 
dados possa ser iniciada.
A instanciação de uma conexão pode ser feita poucas linhas através do método open da classe 
Connector, como no exemplo da figura 12.
Figura 12 – Exemplo de instanciação de conexão Bluetooth®.
3.1.4. Envio e Recebimento de Dados
Instanciada a conexão, já se pode ter acesso aos objetos para troca de dados. Toda conexão tem 
dois objetos para esta tarefa: a InputStream, para recebimento de dados enviados pelo dispositivo alvo, e 
a OutputStream, destinada ao envio de dados ao dispositivo alvo.
As chamadas “Streams” podem enviar e receber dados em vários formatos de maneira 
sincronizada ou não. Se a troca de informações for feita de maneira assíncrona entre os dispositivos, a 
organização e interpretação dos dados se torna um obstáculo, que há de ser transposto pela modelagem de 
um sistema mais robusto para controle de fluxo de dados.
Ambas as instâncias de InputStream e OutputStream podem ser acessadas pela instância de 
Connection, através dos métodos getInputStream e getOutputStream, respectivamente.
4. Instalando o Aplicativo
Depois de concluído o projeto do aplicativo, basta instalá-lo nos aplicativos de destino. Para isso, 
basta compilar o projeto, e utilizar os arquivos .jar e .jad gerados pela compilação (localizados na pasta 
“dist” do projeto Netbeans) para realizar a instalação do aplicativo em celulares, smartphones e outros.
O dispositivo deve ter suporte à plataforma Java para rodar normalmente, e a interface gráfica 
resultante pode variar de formato entre dispositivos móveis devido tanto ao sistema operacional instalado, 
quanto à disposição do teclado do mesmo.