curso tecnólogo em análise e desenvolvimento de sistemas

CURSO TECNÓLOGO EM ANÁLISE E DESENVOLVIMENTO DE
SISTEMAS
EMILIANO MARCOLINO VELASCO
JALINE DA SILVA SOUSA
LEANDRO SOUSA AZEVEDO
ACESSO A BANCO DE DADOS VIA WI-FI, USANDO DISPOSITIVOS
MÓVEIS
Campos dos Goytacazes/RJ
2011
EMILIANO MARCOLINO VELASCO
JALINE DA SILVA SOUSA
LEANDRO SOUSA AZEVEDO
ACESSO A BANCO DE DADOS VIA WI-FI, USANDO DISPOSITIVOS
MÓVEIS
Trabalho apresentado ao Instituto Federal
Fluminense como requisito parcial para a
conclusão do curso de Tecnologia em Análise
e Desenvolvimento de Sistemas.
Orientador: Prof. Ricardo José dos Santos
Barcelos
Campos dos Goytacazes/RJ
2011
EMILIANO MARCOLINO VELASCO
JALINE DA SILVA SOUSA
LEANDRO SOUSA AZEVEDO
ACESSO A BANCO DE DADOS VIA WI-FI, USANDO DISPOSITIVOS
MÓVEIS
Monografia apresentada ao Instituto Federal
Fluminense, como requisito parcial para
conclusão do curso Tecnólogo em Análise e
Desenvolvimento de Sistema.
Aprovada em 06 de junho de 2011.
Banca Avaliadora:
........................................................................................................................................
Prof. Ricardo José dos Santos Barcelos (orientador)
Mestre em Engenharia de Produção pela UENF
Instituto Federal de Educação, Ciência e Tecnologia Fluminense
........................................................................................................................................
Prof. Breno Fabrício Terra Azevedo
Mestre em Informática pela UFES
Instituto Federal de Educação, Ciência e Tecnologia Fluminense
........................................................................................................................................
Prof. Mauricio José Viana Amorim
Mestre em Sistemas e Computação - IME
Instituto Federal de Educação, Ciência e Tecnologia Fluminense
DEDICATÓRIA
Dedicamos este trabalho à nossa família e
todas as pessoas, que contribuíram para nosso
sucesso, crescimento e aprendizado.
AGRADECIMENTOS
Primeiramente
ao
nosso
conhecimento,
aos
nossos
DEUS
pelo
professores
e
orientador, pela paciência, aos familiares e
amigos, pelo apoio e colaboração.
RESUMO
O surgimento de novas tecnologias vem trazendo grandes avanços para o mundo e tem
revolucionado a maneira como as pessoas se comunicam. A comunicação por meio das redes
sem fio e a utilização de dispositivos móveis tem contribuído significativamente para essa
revolução, pois estes possuem a vantagem da disponibilidade de serviço em qualquer lugar e a
qualquer momento. Assim sendo, este trabalho tem como objetivo o desenvolvimento de uma
aplicação que permita o acesso, através de um celular, a qualquer banco de dados. O projeto
foi construído utilizando-se as tecnologias e ferramentas adequadas ao perfil da aplicação.
Palavras-chave: Redes sem fio. Dispositivos móveis. Celular.
ABSTRACT
The emergence of new technologies has brought great advances to the world and has
revolutionized the way how people communicate. The communication through wireless
networks and mobile devices has contributed significantly to this revolution, because they
have the advantage of availability of service anywhere and anytime. Thus, this study aims to
develop an application that allows access to any database via a mobile phone. The project was
built using the technologies and tools to suit the application profile.
Key words: Wireless network. Mobile devices. Mobile phone.
SUMÁRIO
1. Introdução.............................................................................................................................13
1.1 Objetivo .........................................................................................................................14
1.2 Justificativa ....................................................................................................................14
2. A Tecnologia Utilizada .........................................................................................................15
2.1 Configuração CDC (Connected Device Configuration)................................................17
2.1.1 Foundation Profile (FP) .........................................................................................17
2.1.2 Personal Basis Profile (PBP).................................................................................17
2.1.3 Personal Profile (PP) .............................................................................................17
2.2 Configuração CLDC (Connected Limited Device Configuration)................................17
2.3 Perfis ..............................................................................................................................18
2.3.1 IMP (Information Module Profile).........................................................................19
2.3.2 MIDP (Mobile Information Device Profile)...........................................................19
2.4 Midlets ...........................................................................................................................21
2.4.1 O Ciclo de Vida de Um Midlet ..............................................................................22
2.5 Outras Tecnologias - Android ........................................................................................24
2.5.1 Ambiente de implementação Android....................................................................25
2.6 Outras tecnologias - Symbian ........................................................................................26
2.6.1 Ambiente de implementação Symbian...................................................................26
3. Instalação do Ambiente de Desenvolvimento ......................................................................27
3.1 IDE Eclipse ....................................................................................................................27
3.2 Banco de Dados .............................................................................................................27
3.3 Emulador........................................................................................................................27
3.4 Pacotes ...........................................................................................................................28
3.5 Passo a Passo .................................................................................................................29
4. Desenvolvimento da Aplicação ............................................................................................37
5. Conclusão .............................................................................................................................38
6. Referências Bibliográficas....................................................................................................39
7. Anexo 1.................................................................................................................................41
7.1 Diagramas ......................................................................................................................41
7.2 Telas no Smartphone Nokia N95 ...................................................................................43
7.3 Telas no Nokia N78 .......................................................................................................46
7.4 Telas no Smartphone SAMSUNG WAVE 525 ..............................................................48
7.5 Fotos da Apresentação do Pré-Projeto ...........................................................................51
8. Anexo 2.................................................................................................................................53
Lista de Figuras
Figura 1: Visão geral das plataformas Java disponíveis, e das duas camadas adotadas pela
comunidade JCP .......................................................................................................................16
Figura 2: Relação do CDC e do CLCD com a plataforma J2SE..............................................18
Figura 3: Arquitetura básica de um dispositivo CLDC ............................................................19
Figura 4: Os três métodos básicos que compõem o ciclo de vida de uma MIDLet..................22
Figura 5: Ciclo de Vida das MIDlets ........................................................................................23
Figura 6: Arquitetura Android ..................................................................................................24
Figura 7: Simulação de um celular realizada pelo emulador....................................................28
Figura 8: Pacote contendo as bibliotecas necessárias ao desenvolvimento do projeto. ...........28
Figura 9: Verificando a presença do Java na máquina de desenvolvimento ............................29
Figura 10: Site do Eclipse Galileo............................................................................................29
Figura 11: Descompactando o Pacote do Eclipse Galileo ........................................................30
Figura 12: Escolha de Workspace.............................................................................................30
Figura 13: O Ambiente do Eclipse Galileo...............................................................................30
Figura 14: Site do EclipseMe ...................................................................................................31
Figura 15: Esquerda, arquivos baixados a serem transferidos para o Eclipse Galileo .............31
Figura 16: Site da Oracle para download do Tollkit.................................................................32
Figura 17: Termo de Aceitação da Instalação do Sun Java Tollkit...........................................32
Figura 18: Inserindo o path do diretório Java...........................................................................33
Figura 19: Inserindo diretório para instalação..........................................................................33
Figura 20: Confirma instalação do toolkit................................................................................33
Figura 21: Resultado instalação do toolkit ...............................................................................33
Figura 22: Janela com as opções de criação de uma MIDlet....................................................34
Figura 23: Janela de criação de um projeto MIDlet .................................................................34
Figura 24: Importando emulador para o projeto.......................................................................35
Figura 25: Finalizando a criação do projeto MIDlet ................................................................35
Figura 26: Visão do eclipse com o projeto MIDlet criado .......................................................36
Figura 27: Visão das opções de configuração do arquivo JAD................................................36
Figura 28: Diagrama de Sequência - Funcionamento Geral da Aplicação...............................41
Figura 29: Diagrama de Caso de Uso.......................................................................................41
Figura 30: Diagrama de Classe - Pessoa ..................................................................................42
Figura 31: Diagrama de Estrutura de Dados - Pessoa ..............................................................42
Figura 32: NOKIA N95 - Imagem do Celular Pedindo acesso à rede Wi-Fi. ..........................43
Figura 33: NOKIA N95 - Escolha da rede Wi-Fi .....................................................................43
Figura 34: NOKIA N95 - Lista de Dados retornados da consulta ao bancos...........................44
Figura 35: NOKIA N95 - Escolhendo a opção de Inserir um Novo Registro ..........................44
Figura 36: NOKIA N95 - Tela de Inserção de Dados...............................................................44
Figura 37: NOKIA N95 - Dados inseridos na tela....................................................................44
Figura 38: NOKIA N95 - Gravando os dados inseridos, no banco de dados ...........................45
Figura 39: NOKIA N95 - Lista Atualizada com o novo registro inserido................................45
Figura 40: NOKIA N95 - Escolhendo opção de exclusão........................................................45
Figura 41: NOKIA N95 - Tela Atualizada após exclusão de arquivo.......................................45
Figura 42: NOKIA N78 - Imagem do Celular Pedindo acesso à rede Wi-Fi ...........................46
Figura 43: NOKIA N78 - Dados inseridos na tela....................................................................46
Figura 44: NOKIA N78 - Escolhendo a opção de Gravar os dados inseridos na tela no banco
de dados. ...................................................................................................................................47
Figura 45: NOKIA N78 - Escolhendo a opção de Excluir os dados no banco de dados..........47
Figura 46: SANSUMG WAVE 525- Imagem do Celular Pedindo acesso à rede Wi-Fi. .........48
Figura 47: SANSUMG WAVE 525- Lista de Dados retornados da consulta ao banco ...........48
Figura 48: SANSUMG WAVE 525- Dados inseridos na tela...................................................49
Figura 49: SANSUMG WAVE 525- Lista atualizada com as informações do banco de dados
..................................................................................................................................................49
Figura 50: SANSUMG WAVE 525- Escolhendo a opção de Inserir um Novo Registro .........50
Figura 51: SANSUMG WAVE 525- Tela de Inserção de Dados..............................................50
Figura 52: Imagem da Apresentação da Aplicação modelo, celular conectado ao computador
..................................................................................................................................................51
Figura 53: Imagem do Celular conectado ao Notebook e um monitor espelhando a imagem do
notebook. ..................................................................................................................................51
Figura 54: Aluna Jaline mostrando o funcionamento do sistema.............................................52
Figura 55: Imagem da Apresentação da Aplicação desenvolvida. ...........................................52
Lista de Siglas
CDC - Configuração destinada para dispositivos com maior capacidade computacional, como
TV Digital, PDAs de alto desenpenho e sistemas automotivos.
CLDC - (Configuração Limitada de Dispositivos Conectados) Configuração destinada a
dispositivos com menor capacidade computacional, geralmente utilizada em aplicações
embarcadas, teclefones celulares e smartphones.
ECLIPSE ME - Plugin da IDE Eclipse para ajudar no desenvolvimento de aplicativos J2ME
MIDlets
HANDED KEYBOARD - Teclado manual
IDE - (IDE - Integrated Development Environment) IDE é um ambiente integrado para
desenvolvimento de software.
J2ME - Java 2 Micro Edition, base para desenvolvimento de aplicativos Java para
dispositivos móveis.
JRE - Java Runtime Environment (Ambiente de Tempo de Execução Java)
JVM - Java Virtual Machine (Máquina Virtual Java)
KVM - Máquina Virtual que fornece recursos comuns de computação.
MIDLET - Aplicação Java destinada a dispositivos móveis como celulares, smartphones e
outros dispositivos que implementem o perfil MIDP.
WIRELESS - Redes sem fio, também conhecidas como IEEE 802.11, Wi-Fi ou WLANs, são
redes que utilizam sinais de rádio para a sua comunicação.
PAGER - É um dispositivo eletrônico usado para contactar pessoas através de uma rede de
telecomunicações.
AWT - Abstract Window Toolkit, foi o primeiro toolkit para criação de interfaces para
dispositivos moveis em Java.
APPLETS - É um programa escrito em linguagem de programação Java que podem ser
incluídos em uma página HTML.
RUNTIME - Tempo de Execução
PDA - Assistente pessoal digital
IP - Internet Protocol - Protocolo de Internet
TCP - Transmission Control Protocol - Protocolo de Controle de Transmissão
TCP/IP - Arquitetura desenvolvida para Internet
WAP - Wirelles Application Protocol - Protocolo de aplicação sem fio - é um protocolo de
comunicação e ambiente de aplicações para a distribuição de recursos de informação.
1. Introdução
Nos últimos anos o uso de dispositivos móveis vem se tornando cada vez mais
acessíveis aos indivíduos devido ao baixo custo, acessibilidade e facilidade de comunicação.
Por meio da utilização de redes locais sem fio e via satélite é possível disponibilizar serviços
em qualquer lugar e em qualquer momento. Cada vez mais é comum a comunicação entre
dispositivos de naturezas distintas, como a transmissão de dados entre aparelhos celulares e
computadores pessoais. A tecnologia Wireless (comunicação sem fio) constitui um novo
paradigma de comunicação e representa uma revolução na forma de comunicação em rede.
A comunicação sem fios ainda apresenta muitos problemas relacionados à segurança.
Os riscos, com relação à segurança, nesta forma de transmissão de dados podem e devem ser
minimizados, aplicando-se a configuração recomendada, como a utilização de senhas e
criptografia, pois é importante ressaltar que não existe rede totalmente segura, qualquer que
seja a forma de comunicação.
Os avanços tecnológicos têm sido cada vez mais crescentes, a cada instante uma nova
tecnologia é desenvolvida. O celular é um exemplo desse novo mercado que vem evoluindo
cada vez mais. As empresas de telefonia móvel investem na pesquisa e no desenvolvimento
de novos aplicativos para serem funcionais para seus aparelhos, com o objetivo de aumentar o
número de usuários.
O desenvolvimento de aplicações para dispositivos móveis requer um conjunto de
ferramentas específicas que proporcionem um ambiente adequado de acordo com as
especificidades dos aparelhos. Pelo fato de celulares conterem quantidade de memória e
capacidade de processamento limitados, bem como discernirem significativamente suas
configurações entre os mais diversos modelos.
Existem atualmente poucas linguagens de programação com o objetivo de desenvolver
aplicações para dispositivos móveis. A plataforma J2ME é a mais utilizada para estes
dispositivos, devido à facilidade de implementação da linguagem de programação Java, por
meio da adição de classes ou bibliotecas para o desempenho de determinada tarefa, além de
ser uma linguagem orientada a objeto, fator este que facilita o entendimento do projeto, pois
visa um desenvolvimento mais próximo possível da realidade.
A linguagem Java se destaca pelo suporte a criação de aplicativos para dispositivos
móveis, a maioria dos aparelhos móveis possui suporte ao Java. Uma plataforma específica
com suporte para esse tipo de aplicação é o J2ME que cria as Midlets, que são as classes que
14
um celular com suporte a Java interpreta, gerando uma gama de recursos a serem
programados.
A praticidade de acesso e a rapidez na execução das tarefas do dia a dia, tornam o
papel dos softwares para dispositivos móveis essenciais. O suporte à rede Wi-Fi nos aparelhos
móveis é um ponto a se destacar, pois este aumenta a capacidade de um aplicativo Java
desenvolvido para dispositivos móveis. Uma das utilidades é o acesso à servidores web já
existentes para a realização de uma determinada tarefa com maior praticidade e comodidade,
sem necessitar o uso de um computador para a realização de tarefas mais simples.
1.1 Objetivo
O objetivo do projeto é desenvolver uma aplicação para disponibilizar um sistema que,
com o uso de dispositivos móveis, realize acessos a banco de dados utilizando a comunicação
de rede sem fio.
1.2 Justificativa
O sistema de acesso a banco de dados via rede sem fios, promove aos usuários de
dispositivos móveis uma gama de aplicativos facilitadores para o seu cotidiano. Com base no
estudo realizado neste projeto, o programador será capaz de desenvolver diversos aplicativos
com acesso a servidores de internet ou intranet, ou como desejar.
Os dispositivos móveis tem a possibilidade de serem utilizados com diversos tipos de
conexão, sendo que para alunos oriundos de instituição pública a conexão com a internet é
muito cara.
Porém, o mínimo de alunos que possuem dispositivos móveis é significativo, podendo
afirmar que 100% tem celular.
O sistema proposto possibilita acesso à rede da instituição sem utilização da internet,
isto é, sem custo.
2. A Tecnologia Utilizada
Foi utilizada a plataforma J2ME, que tem como finalidade disponibilizar uma JVM
(Java Virtual Machine), API (Application Programming Interface) e um conjunto de
ferramentas para o desenvolvimento de aplicações móveis. J2ME fornece um JRE (Java
Runtime Environment) otimizado especialmente voltado para o mercado de grande consumo,
onde é cada vez maior o número de dispositivos móveis suportando aplicações desenvolvidas
em J2ME.
Atualmente existem três plataformas Java disponíveis. São elas:
•
Standard Edition (J2SE): Projetado para funcionar em computadores desktop e
estações de trabalho.
•
Enterprise Edition (J2EE): Com suporte embutido para Servlets, JSP, XML, esta
edição é destinada a aplicações para servidores.
•
Micro Edition (J2ME): Projetado para dispositivos com memória, display e
capacidade de processamento limitados.
Embora a plataforma J2ME seja voltada para o desenvolvimento de aplicações
móveis, foi necessário que a dividissem em duas abordagens segundo as necessidades dos
dispositivos portáteis. Isto se dá pelo fato das diversas capacidades dos mesmos. Um
Screenphone Internet (um dispositivo de hardware projetados para fornecer acesso a email,
notícias, online banking, etc) pode ter display, memória e capacidade de processamento
relativamente maiores do que um pager. No entanto, mesmo dispositivos que pareçam
semelhantes podem variar também nesses aspéctos de memória e processamento. Assim
sendo foram categorizadas duas camadas: Configuração e Perfil.
A primeira abordagem foi denominada Configurações, onde foi definido um JRE
(Java Run-Time Environment) e um conjunto de classes básicas chamadas de core. Uma
configuração define qual a máquina virtual a ser utilizada de acordo com o dispositivo em
questão. Existem duas configurações para dispositivos móveis, a CDC (Connected Device
Configuration) e a CLDC (Connected Limited Device Configuration). Para o CDC, a máquina
virtual tem basicamente a mesma especificação do J2SE, utilizando a CVM como máquina
16
virtual. Para CLDC, a Sun1 desenvolveu o que é referido como uma implementação de
referência de uma máquina virtual, conhecida como a Máquina Virtual K. Portanto entendese que a KVM e a CVM não são a "tradicional" máquina virtual Java. Logo, KVM e a CVM
são implementações da Sun de JVM que se encaixa com as orientações do CLDC.
A segunda abordagem foi definida como Perfil, que consiste em um conjunto de
classes que visam oferecer ao programador os recursos necessários para o desenvolvimento de
aplicações voltadas para o perfil individual do dispositivo.
A Figura 1 mostra a arquitetura básica das três plataformas Java versão 2, disponíveis
atualmente:
Figura 1: Visão geral das plataformas Java disponíveis, e das duas camadas adotadas pela
comunidade JCP
Fonte: http://www.developer.com/ws/j2me/article.php/1441091/The-Basics-of-J2ME.htm
Após compilar o código-fonte Java em um arquivo de classe e opcionalmente, incluir
em um arquivo JAR, a JVM converte os arquivos de classe (mais precisamente, o código de
bytes nos arquivos de classe) para a plataforma que está executando a JVM. A JVM também é
responsável por oferecer segurança, alocar, liberar memória e gerenciamento de threads.
Estes, por sua vez, podem ser definidos como processos paralelos, onde cada um possui
uma fatia de tempo para a sua execução. Isso possibilita a execução de múltiplas tarefas nos
sistemas multitarefa.
1
Empresa responsável pela criação do Java, atualmente mantido pela Oracle
17
2.1 Configuração CDC (Connected Device Configuration)
Esta configuração foi proposta para o desenvolvimento de aplicações para dispositivos
com uma maior capacidade computacional, como os set-top boxes, PDAs, sistemas
automotivos etc. Neste momento estão disponíveis os seguintes perfis:
2.1.1 Foundation Profile (FP)
Encontra-se no nível mais baixo do CDC. Não possui suporte à interface com o
usuário. O pacote javax.awt.* não se encontra disponível. Esse perfil é necessário para os
demais perfis CDC.
2.1.2 Personal Basis Profile (PBP)
Suportam um nível básico de interface com o ususário e utiliza-se de toolkits para
executar tarefas.
2.1.3 Personal Profile (PP)
Perfil CDC utilizado para aplicações que necessitam de um suporte completo para
interface. Adiciona bibliotecas gráficas ao Foundation Profile através de ambiente com total
suporte a AWT.
A intenção dos criadores desse perfil era possibilitar uma plataforma
adequada para Applets.
As seguintes características são encontradas num dispositivo CDC:
•
processador de 32 bits
•
2MB de memória RAM para o ambiente runtime Java
•
conectividade geralmente a rede sem fio
2.2 Configuração CLDC (Connected Limited Device Configuration)
Foi
desenvolvida para aplicações
em
dispositivos
com
baixa capacidade
computacional, como os celulares e pagers.
As seguintes características são as mínimas necessárias para o desenvolvimento de uma
aplicação no CLDC:
•
160kB a 512kB de memória disponível para a plataforma Java
•
processador de 16 a 32 bits
18
•
baixo consumo de energia, freqüentemente usando energia de baterias
•
conectividade a algum tipo de rede, em geral sem-fio.
2.3 Perfis
Um perfil J2ME define uma plataforma Java mais definida e focada para um mercado,
categoria de dispositivo, ou indústria em particular. No núcleo da implementação CLDC está
a JVM que, à parte das diferenças específicas definidas na especificação, é de acordo com a
especificação para JVMs e linguagem Java. A JVM tipicamente executa acima do sistema
operacional que está fora do escopo da especificação.
Figura 2: Relação do CDC e do CLCD com a plataforma J2SE
Fonte: http://www.ifi.uzh.ch/~riedl/lectures/Java2001-j2me.pdf
A Figura 2 ilustra a relação do CDC e do CLCD com a plataforma J2SE. O CDC
utiliza basicamente a mesma especificação da plataforma J2ME. O CLDC também utiliza um
conjunto de classes básicas do modelo J2SE. Porém na representação da figura, a parte que se
encontra fora da área J2ME significa as especificações de cada configuração. As classes que
estão fora do ambiente J2SE não podem utilizar o java.*.
Ao topo da JVM estão as bibliotecas, que são divididas em duas categorias:
•
as definidas pelo CLDC
•
as definidas pelos perfis
19
Figura 3: Arquitetura básica de um dispositivo CLDC
Fonte: http://www.inf.ufrgs.br/gppd/disc/inf01008/trabalhos/sem01-1/t2/pitoni/
Desta forma a configuração CLDC define um conjunto de especificações para
dispositivos com baixa capacidade computacional de forma mais genérica, enquanto que os
perfis (Figura 3) definem as especificidades de forma mais particular. Existem atualmente
dois perfis para o CLDC. São eles o IMP (Information Module Profile) e o MIDP (Mobile
Information Device Profile).
2.3.1 IMP (Information Module Profile)
Quando combinado com o Connected Limited Device Configuration (CLDC), as
Informações do Módulo Profile (IMP) fornecem um ambiente de aplicações Java para
dispositivos móveis, que não possuem grandes capacidades de exibição gráfica, ou cujos
recursos gráficos são limitados. Entre os exemplos incluem caixas de chamada de emergência,
parquímetros, módulos sem fio em sistemas de alarme residenciais, industriais e dispositivos
de medição.
Em um pacote padronizado de APIs Java, IMP fornece a funcionalidade básica do
aplicativo necessário à máquina, incluindo conectividade de rede, armazenamento de dados
locais, e gerenciamento de aplicações de ciclo de vida.
2.3.2 MIDP (Mobile Information Device Profile)
MIDP é um elemento-chave da plataforma Java 2 Mobile Edition (J2ME). Quando
combinado com o Connected Limited Device Configuration (CLDC), MIDP fornece um
ambiente de execução Java padrão para os mais populares dispositivos de informação móvel
atualmente, como telefones celulares e os PDAs. A especificação do MIDP foi definida
através do Java Community Process (JCP), para fabricantes que possuem maior liderança no
desenvolvimento de dispositivos, operadoras e fornecedores de software para dispositivos
móveis, e define uma plataforma dinâmica e segura, para a implantação otimizada, gráficos e
aplicações de rede.
20
O MIDP 2.0 superou em capacidade, porém, vários dispositivos suportam apenas
MIDP 1.0 com isto a maioria dos desenvolvedores não podem ignorar a versão anterior.
Existem duas versões do IMP; versão 1.0 é baseada em MIDP 1.0; e versão da Next
Generation (NG) é baseada na MIDP 2.0.
O MIDP é a definição de uma arquitetura e APIs para prover um ambiente de
desenvolvimento aberto para MIDs (mobile information devices). O MIDP foi feito para
executar sobre CLDC. Para tanto, um MID deve possuir as seguintes características mínimas
de hardware (além das que são requeridas pelo CLDC):
Display:
•
Tamanho da tela: 96x54;
•
Profundidade: 1 bit;
•
Formato do pixel (proporção de aspecto): 1:1;
Input:
•
“One handed keyboard” ou
•
“Two handed keyboard” ou
•
Touch Screen;
Memória:
•
128 Kbytes para os componentes MIDP;
•
8 Kbytes para dados das aplicações;
•
32 Kbytes para o JAVA runtime;
Rede:
•
Duplex, sem fio, possivelmente intermitente e com largura de banda limitada.
Como os MIDs possuem uma grande quantidade de potencialidades, este é limitado ao
conjunto de APIs necessárias para aquelas que precisam alcançar uma grande portabilidade.
São as seguintes:
- Aplicação: O Ciclo de Vida de uma MIDlet não deve possuir um método public void
static main (). O software de gerenciamento de aplicação deve suprir a classe inicial
necessária pelo CLDC para iniciar a MIDlet. Quando uma MIDlet é instalada, esta é mantida
no aparelho e está disponível para ser utilizada. Quando é executada, uma instância é criada
através de seu construtor público sem argumentos, e seus métodos são chamados para mudar e
passar pelos estados da MIDlet. Quando é terminada, é destruída, e os recursos utilizados por
21
ela podem ser recuperados, incluindo os objetos criados e suas classes.
- Interface do Usuário;
- Persistent Storage: O MIDP disponibiliza um mecanismo para que as MIDlets
possam guardar dados e lê-los mais adiante. Este mecanismo é conhecido como Record
Management System (RMS).
- Record Stores: É uma coleção de registros que permanece o mesmo durante múltiplas
chamadas do MIDlet. A plataforma é responsável por manter a integridade desses registros,
mesmo após reboots ou trocas de baterias.
- Records: São vetores de bytes. Utilizados para armazenagem de diferentes tipos de
dados. Eles são unicamente identificados pelo seu recordId, um valor inteiro.
- Rede: O MIDP herda a conectividade do CLDC e suporta um subconjunto do HTTP,
que pode ser implementado com protocolos IP (TCP/IP) e não-IP (WAP e i-mode). A interface
HttpConnection possui funcionalidades que permitem a realização de funções específicas do
HTTP. Qualquer aparelho que implemente MIDP deve suportar o HTTP 1.1, requisições
HEAD, GET, POST e forms.
-Temporizadores (timers): Aplicações que necessitem agendar tarefas para um tempo
futuro pode utilizar as classes Timer e TimerTask, que incluem funções para uma execução ou
várias
execuções
em
determinados
intervalos.
Elas
estão
em
java.util.Timer
e
java.util.TimerTask.
Em suma pode-se dizer que a configuração visa aparelhos que possuem recursos de
hardware semelhantes, enquanto que o perfil visa aparelhos que executem tarefas
semelhantes.
2.4 Midlets
MIDLETS são os aplicativos que são executados nos dispositivos móveis na
plataforma J2ME. Todas as aplicações desenvolvidas nesta plataforma são chamadas de
MIDLETS. Para tanto, a classe MIDlet deve ser importada no início da aplicação, ou seja, a
22
classe principal do aplicativo deve ser uma subclasse da classe MIDlet, este deve ser
empacotado em um arquivo.jar e o mesmo necessita ser pré-verificado. Após a aplicação ter
sido compilada, esta necessita passar pelo processo de verificação, processo este somente
existente para aplicações em J2ME.
A memória de dispositivos portáteis é muito pequena, portanto, o perfil MIDP e a
configuração CLDC especificaram que o processo de verificação do bytecode se daria em
duas partes. Forma externa ao dispositivo, arquivos de classes são verificados e recompilados
num formato que possa ser manipulado facilmente pelo segundo passo.
No dispositivo é realizado o segundo passo da verificação após as classes serem
carregadas. Caso algum dos arquivos de classe não tenha sido pré-verificado, será rejeitado.
Por isso a necessidade de pré-verificação dos arquivos. Esse procedimento é importante, pois
é uma das bases para o modelo de segurança em tempo de execução Java. Na versão J2ME
Wireless esse processo é realizado automaticamente.
2.4.1 O Ciclo de Vida de Um Midlet
O ciclo de vida de um MIDlet é composto de três métodos obrigatórios. Conforme as
Figura 4 e 5:
Figura 4: Os três métodos básicos que compõem o ciclo de vida de uma MIDLet
Protected void startApp(){}: Este método é responsável por iniciar a aplicação. A
inicialização da aplicação deve estar alocada neste método.
23
Protected void pauseApp(){}: Este método é responsável por pausar a aplicação
mediante interrupções. Neste caso, a aplicação permanece executando no dispositivo até que
seja reiniciada.
Protected void destroyApp(boolean arg){}: Esse método é disparado para destruir a
aplicação, ou seja, finalizá-la. Quando o método destroyApp é acionado, a aplicação é fechada
e todas as suas instâncias são apagadas da memória. O parâmetro booleano, caso seja true
(verdadeiro), fecha a aplicação sem aviso prévio. Caso seja false (falso) o dispositivo avisa
que quer destruir o MIDlet e este por sua vez, poderá executar uma Exception de troca de
estado para avisar ao dispositivo sobre uma tarefa importante que está realizando.
Com o ambiente de desenvolvimento definido, pode-se criar um novo projeto MIDlet
e em seguida criar uma classe MIDlet, a qual será criada com os métodos padrões que são
necessários para o funcionamento adequado de uma MIDlet em um aparelho celular.
Figura 5: Ciclo de Vida das MIDlets
24
2.5 Outras Tecnologias - Android
Android é um ambiente operacional baseado no kernel Linux® V2.6, um produto do
Open Handset Alliance2, grupo liderado pelo Google. Os aplicativos Android são gravados na
linguagem de programação Java e são executados em uma DVM(Dalvik Virtual Machine),
diferentemente da JVM (Java Virtual Machine) para a plataforma J2ME. A arquitetura do
Android pode ser definida como uma pilha de softwares, onde cada camada da pilha agrupa
programas com funções específicas.
A base da pilha é o kernel, que inclui os programas de gerenciamento de memória, as
configurações de segurança, o software de gerenciamento de energia e vários drivers de
hardware para o controle do mesmo, como por exemplo, câmeras fotográficas. O próximo
nível inclui as bibliotecas do Android e a camada de tempo de execução. A Figura 6 mostra a
arquitetura de um sistema Android.
A próxima camada é o framework de aplicação que inclui os programas que gerenciam
as funções do dispositivo, como alocação de recursos, mudança entre processos etc. No topo
da pilha estão as aplicações em si, onde se encontram as funções básicas do dispositivo, como
fazer chamadas telefônicas, acessar o navegador web ou acessar uma lista de contatos.
Figura 6: Arquitetura Android
Fonte: http://www.redrails.com.br/2011/04/google-android-como-um-ambiente-dedesenvolvimento-de-aplicacoes-para-sistemas-de-decodificacao-de-dtv-tv-digital/
Um aplicativo Android consiste em uma ou mais das classificações a seguir:
•
Atividades - No momento que um usuário seleciona um aplicativo, uma atividade é
iniciada.
2
Grupo de companhias de hardware, software e telecomunicação dedicadas ao projeto de plataforma Android
25
•
Serviços - Um serviço deve ser utilizado para qualquer aplicativo que precise persistir
por um longo período de tempo.
•
Provedores de conteúdo - gerencia o acesso aos dados que persistem, caso o aplicativo
seja pequeno, não é necessário.
•
Receptores de transmissão - Utilizado para processar um elemento de dados ou para
responder a um evento.
As principais versões do Android lançadas no mercado até o presente momento são:
•
1.5 (Cupcake) - Primeira versão lançada em um grande número de aparelhos.
•
1.6 (Donut) - Utilizada em aparelhos com capacidade computacional limitada.
•
2.0 / 2.1 (Eclair) - Melhoria da versão 1.6. Ainda bastante utilizada.
•
2.2 (Froyo) - Melhorias na velocidade dos aplicativos e navegador.
•
2.3 (Gingerbread) - Versão para smartphones.
•
3.0 / 3.1 (Honeycomb) - Versões exclusivas para tablets.
2.5.1 Ambiente de implementação Android
Os ambientes de desenvolvimento suportados são:
IDE Eclipse - Para o desenvolvimento de aplicações na plataforma Android, é possível
utilizar-se a IDE Eclipse ou outra IDE de acordo com a preferência do desenvolvedor ou
ainda utilizar editores de texto e ferramentas de linha de comando, pois o Android Plugin
para Eclipse funciona simplesmente como um empacotador das ferramentas incluídas no SDK
e, portanto, opcional.
Recomenda-se:
•
IDE Eclipse 3.5 (Galileo) ou superior;
•
Eclipse JDT Plug-in (incluído na maioria dos pacotes Eclipse IDE);
•
Possibilidades de escolha de pacotes e ambientes de execução:
o Eclipse IDE para Java Developers;
o Eclipse Classic (versões 3.5.1 ou superior);
o Eclipse IDE para Java EE Developers;
o JDK (Java Development Kit) – versões 5 ou 6 ;
o JRE (Java Runtime Environment)
o Apache Ant 1.8 ou superior;
•
SDK (Software Development Kit) O download do SDK está disponível em arquivos
26
com extensão .zip e .exe para Windows, .zip para Mac OS X (Intel) e .tgz para
Linux(i386).
•
ADT (Android Development Tools) - Plugin que estende as capacidades do Eclipse
para permitir a inicialização rápida de novos projetos Android, criar aplicações para o
usuário (UI), adicionar componentes baseados no Android Framework API, corrigir
aplicações usando as ferramentas Android SDK, e ainda exportar arquivos a fim de
distribuir as aplicações.
2.6 Outras tecnologias - Symbian
Symbian é um Sistema Operacional voltado para o mercado de dispositivos
embarcados, ou dispositivos móveis. É um grupo composto pelas principais empresas do
ramo de software para equipamentos portáteis.
O SO Symbian é modular, ou seja, não possui uma interface definida, o que
proporciona às empresas criarem sua própria interface, podendo ser desde um simples sistema
de texto em telas monocromáticas até sistemas complexos com recursos mais avançados.
O Sistema Operacional Symbian visa à otimização de seus recursos como bateria e
memória, evitando seu desperdício. É um sistema de baixo custo, aberto, permite a instalação
de softwares de terceiros, além de permitir o desenvolvimento de aplicações em diversas
linguagens, tais como Java ME, Python, Ruby, entre outras.
2.6.1 Ambiente de implementação Symbian
O ambiente de implementação necessita das seguintes aplicações:
•
Java Runtime Environment - Ambiente de execução Java; Provê uma base para a
construção e execução de diversas aplicações.
•
Active Perl - Núcleo para programação Perl.
•
S60 Platform SDK for Symbian OS - Conjunto de softwares para o desenvolvimento
de aplicações para dispositivos móveis.
•
Carbide - framework da Nokia baseado na IDE Eclipse para o desenvolvimento de
software para múltiplas plataformas do Symbian OS e em múltiplas linguagens.
3. Instalação do Ambiente de Desenvolvimento
3.1 IDE Eclipse
Para o desenvolvimento de uma aplicação modelo foi utilizada a IDE Eclipse,
desenvolvida por uma comunidade open source (código livre) sem fins lucrativos, com o
objetivo de proporcionar o desenvolvimento de softwares que auxiliam no desenvolvimento
de sistemas.
Para as aplicações que visam ambiente Web, utilizou-se a tecnologia JSP (Java Server
Pages) para a criação das páginas que fazem o acesso ao banco de dados e retornam os
devidos resultados para a solicitação. Como servidor de aplicação foi utilizado o Glassfish3,
em sua versão 2.1.
3.2 Banco de Dados
Uma ferramenta importante para o armazenamento das informações necessárias de
serem tratadas é o banco de dados. Para tanto, utilizou-se o banco de dados PostgreSQL, que
também é de origem open source, com distribuição gratuita.
3.3 Emulador
A utilização dos emuladores possibilita que a aplicação seja testada por meio do
fornecimento de uma interface genérica de um dispositivo móvel. Desta forma não há a
necessidade da geração contínua de pacotes para a realização desta tarefa. No software
emulador é exibido todo o funcionamento da aplicação. O emulador utilizado no projeto foi o
SUN JAVA TOOLKIT, possibilitando a criação dos pacotes de arquivos com a extensão .JAR,
formato no qual é permitido o funcionamento de aplicações nos celulares. A Figura 7 ilustra
como é exibido por meio do software emulador, um dispositivo genérico de celular.
3
Servidor de aplicação para compilação de arquivos Java
28
Figura 7: Simulação de um celular realizada pelo emulador.
3.4 Pacotes
Para o desenvolvimento de aplicações móveis, faz-se necessário que a IDE Eclipse
possua suporte ao desenvolvimento de MIDlets, para isso, foi utilizado o pacote com as
bibliotecas necessárias, para tal necessidade e disponibilizadas no site do EclipseME
(http://sourceforge.net/projects/eclipseme/files/). O pacote possui os seguintes arquivos e
diretórios conforme Figura 8:
Figura 8: Pacote contendo as bibliotecas necessárias ao desenvolvimento do projeto.
29
Os arquivo 'site.xml', ‘features’ e ‘plugings’ foram transferidos para o diretório raiz do
eclipse. Após estas transferências, o eclipse encontra-se com suporte ao desenvolvimento de
aplicações MIDlets.
O próximo passo é a instalação do software emulador (sun java toolkit), que pode ser
encontrado no endereço: http://java.sun.com/products/sjwtoolkit/download.html. Após a sua
instalação, deve-se configurar o eclipse para que reconheça o emulador instalado.
(http://eclipseme.org/docs/configuring.html#step3).
3.5 Passo a Passo
Os passos a seguir são aplicados em um ambiente linux de distribuição Ubuntu4:
- O primeiro passo é abrir o terminal e verificar se o Java encontra-se instalado na
máquina de desenvolvimento, com o comando “java -version”, aparecendo informações
iguais ou semelhantes a Figura 9 é porque significa que o Java está instalado corretamente.
Figura 9: Verificando a presença do Java na máquina de desenvolvimento
- O próximo passo é realizar o download e instalação do Eclipse, o exemplo em
questão é o Eclipse Galileo que encontra-se disponível em http://www.eclipse.org/galileo e
clicar na opção de download, Figura 10.
Figura 10: Site do Eclipse Galileo
4
Ubuntu é um sistema operacional gratuito baseado em Linux mantido pela Canonical.
30
Com o download realizado, basta escolher um local para descompactar o pacote do
Eclipse Galileo e torna-lo apto a ser utilizado, Figura 11.
Figura 11: Descompactando o Pacote do Eclipse Galileo
Ao ser iniciado pela primeira vez, define-se o workspace5, Figura 12, após, é mostrado
o ambiente de trabalho do Eclipse com suas abas e perspectivas, Figura 13.
Figura 12: Escolha de Workspace
Figura 13: O Ambiente do Eclipse Galileo
5
Área de trabalho para desenvolvimento
31
- O próximo passo é realizar o download do EclipeME, disponível em
http://sourceforge.net/projects/eclipseme/files/, Figura 14.
Figura 14: Site do EclipseMe
Com o download realizado, copia-se os arquivos contidos nos diretórios baixados, em
seus respectivos diretórios no eclipse, para que o mesmo consiga trabalhar com MIDlets,
Figura 15.
Figura 15: Esquerda, arquivos baixados a serem transferidos para o Eclipse Galileo
32
- O último pacote a ser instalado é o Sun Java Toolkit, disponível em
http://oracle.com/technetwork/java/download/135801.html, Figura 16.
Figura 16: Site da Oracle para download do Tollkit
Com o download realizado, o passo seguinte é realizar a instalação, abrindo o terminal
do sistema e executando o arquivo, com o comando “./sun_java_wireless_toolkit-2.5.2_01linuxi486.bin.”, e aceitar os termos de utilização, Figura 17.
Figura 17: Termo de Aceitação da Instalação do Sun Java Tollkit
33
Prosseguindo na instalação, escolha a opção 0 (zero) para inserir manualmente o path
(caminho) do diretório Java, recomenda-se que utilize o comando “/usr/bin/X11”, Figura 18.
Figura 18: Inserindo o path do diretório Java
Feito isto, defina o diretório onde será instalado o toolkit, Figura 19, e em seguida
escolha a opção 0 (zero) para confirmar a instalação no diretório informado e o toolkit estará
disponível para uso, Figura 20.
Figura 19: Inserindo diretório para instalação
Figura 20: Confirma instalação do toolkit
Após a instalação concluída, deve aparecer uma resposta como na Figura 21:
Figura 21: Resultado instalação do toolkit
Voltando ao eclipse, já é possível realizar a criação de um projeto do tipo MIDlet, que
por sua vez vem preparado para o desenvolvimento de aplicativos para dispositivos móveis.
Agora, com todos os pacotes necessários instalados, aplica-se a criação de um projeto
do tipo MIDlet e configura-lo para que o mesmo funcione devidamente, para isso, realiza-se
34
as seguintes instruções:
- Clicar em “File > New > Project”;
- Escolher a pasta “J2ME”;
- Duplo clique sobre “J2ME Midlet Suíte”, Figura 22;
- Dar nome ao Projeto, Figura 23;
Figura 22: Janela com as opções de criação de uma MIDlet
Figura 23: Janela de criação de um projeto MIDlet
35
- Configurar o Emulador no projeto, informando o dispositivo que irá ser utilizado,
Figura 24;
Figura 24: Importando emulador para o projeto
- Clicar em “Next” seguido de “Finish” para criar o projeto MIDlet, Figura 25.
Figura 25: Finalizando a criação do projeto MIDlet
36
Com o projeto criado, tem-se a seguinte visão das camadas de um projeto MIDlet,
Figura 26.
Figura 26: Visão do eclipse com o projeto MIDlet criado
No projeto MIDlet criado, pode-se ver uma estrutura interna de funcionamento pré
definida, uma delas é o arquivo com extenção JAD, onde ficam armazenadas as informações
como nome, tamanho, versão, configuração dentre outras opções, como pode-se ver na Figura
27.
Figura 27: Visão das opções de configuração do arquivo JAD
4. Desenvolvimento da Aplicação
Para que seja criada uma aplicação para celular utilizando-se a tecnologia Java, é
necessário fazer uso da classe MIDlet, a qual fornece suporte à funcionalidades e acesso a
métodos que os celulares já identificam e reconhecem, para tratar as informações, a partir
desse ponto, a implementação de aplicações torna-se possível da forma que for desejada.
A aplicação tem por necessidade fazer a conexão com um banco de dados para a
transmissão das informações, utilizou-se a rede Wi-Fi para estabelecer a conexão
primeiramente ao servidor web, onde é acessado via url os valores para a consulta ao banco.
Este procedimento é necessário, pois, atualmente, ainda não está disponível tecnologia para
que o celular interaja diretamente com um banco de dados convencional.
Uma página web comum se encarrega de criar uma espécie de ponte entre o
dispositivo e o banco de dados, desta forma, esta página faz o acesso ao banco e retorna a
solicitação para o aparelho de celular.
O funcionamento é realizado com a passagem de parâmetros para uma url
determinada, onde, receberá os parâmetros e fará o que está programado para realizar (inserir,
alterar, excluir, listar), retornando os valores desejados, os quais serão repassados para a
MIDlet que exibirá na tela do celular.
O funcionamento de uma MIDlet realizando conexão com o banco de dados, é
possível com qualquer que seja o banco de dados, desde que o mesmo seja acessado por uma
página de servidor web, podendo ser em qualquer linguagem, desde que a mesma atenda a
pré-condição da possibilidade de receber parâmetros.
A aplicação MIDlet necessitou de métodos para o tratamento do envio e recebimento
dos parâmetros, uma vez que, a passagem de parâmetros que contenha em seu valor espaços
em branco, ocorrerá em erro na requisição, não realizando a tarefa como desejado, para isto,
foram substituídos os caracteres referentes ao espaço em branco pelo %20 que representa o
mesmo caracter.
5. Conclusão
Os dispositivos móveis têm disseminado em todas as classes sociais e em principal aos
alunos que podem acessar Servidores de dados sem custo. Isto motiva a construção desta
aplicação para utilizar o celular como meio de acesso à Servidores de dados, sem a utilização
de internet.
O desenvolvimento da aplicação de acesso a banco de dados para dispositivos móveis
foi possível utilizando-se as ferramentas e tecnologias adequadas, bem como a utilização de
banco de dados e servidor mais apropriados, embora fosse possível o uso de outros bancos,
servidores e linguagens.
Por meio da utilização das redes sem fio estabeleceu-se a transmissão de dados, pois
esta constitui hoje uma revolução na forma de comunicação podendo ter seu alcance
geográfico limitado ou não, o que oferece suporte à implementação de diferentes tipos de
sistemas. O uso dos aparelhos móveis vem se tornando cada vez mais crescentes, dada a
popularização de seu custo e disponibilidade de serviço a qualquer hora e em qualquer lugar.
O projeto desenvolvido constitui uma alternativa a diversos sistemas já existentes no
mercado, possibilitando a vantagem da comodidade e disponibilidade de acesso a diversas
funcionalidades, dispensando o uso de um computador. Portanto o sistema apresenta
condições para ser implementado e utilizado para as mais diversas áreas, salvo observadas as
devidas requisições podendo futuramente ser utilizado para diversas aplicações educacionais
como o aluno acessar ao registro acadêmico acessar a materiais de apoio inserido pelo seu
professor, entre outros diversos recursos que poderiam ser disponibilizados, ampliando o meio
de acesso à informação.
6. Referências Bibliográficas
CAGNOTTO, Vinícius, Desenvolvimento J2ME – Criando seu Ambiente. Disponível em:
<http://viniciuscagnotto.wordpress.com/2010/03/19/desenvolvimento-j2me-criando-seuambiente/> . Acessado em: 25/10/2010.
CERT.BR, Cartilha de segurança: redes de banda larga e sem fio. Disponível em:
<http://cartilha.cert.br/bandalarga/sec2.html>. acessado em: 09/05/2011
ECLIPSE
ME,
Configuração
EclipseME
and
Eclipse
.
Disponível
em:
<http://eclipseme.org/docs/configuring.html#step3>. Acessado em: 24/10/2010.
ECLIPSE
ME,
Creating
a
new
J2ME
MIDlet
Project.
Disponível
em:
<http://eclipseme.org/docs/createProject.html#convert>. Acesso em: 24/10/2010.
FERNANDES, Rodolfo Chaves. Iniciando no desenvolvimento com java me. Disponível em:
<http://www.javamovel.com/2010/10/iniciando-no-desenvolvimento-com-java.html>
.
Acessado em: 26/10/2010.
HOWELL, Rick. WAP – Wireless Application Protocol. São Paulo: Makron Books, 2001.
MARTINS, Renato Passarinho. Java2ME ou J2ME - Tutoriais de programação em português.
Disponível
em:
<http://www.wirelessbrasil.org/wirelessbr/secoes/sec_java2me.html>
.
Acessado em: 20/10/2010.
MATTOS, Érico Tavares de. Programação Java para wireless - Aprenda a desenvolver
sistemas em J2ME!. São Paulo: Digerati Booksm, 2005.
NEITZKE,
Neri,
Canoas
-
RS.
Java
ME
II.
Disponível
em:
Disponível
em:
<http://www.youtube.com/user/nerineitzke> . Acessado em: 26/10/2010.
ORACLE,
O
que
é
a
tecnologia
"Mobile"
Java?
<http://www.java.com/pt_BR/download/faq/what_mj.xml>. Acessado em: 22/10/2010.
40
ORACLE, Tenho o KVM instalado em meu celular. O que é isso?. Disponível em:
<http://www.java.com/pt_BR/download/faq/what_kvm.xml> . Acessado em: 22/10/2010.
ORACLE,
O
que
é
J2ME?.
Disponível
em:
<http://www.java.com/pt_BR/download/faq/whatis_j2me.xml>. Acessado em: 22/10/2010.
ORACLE, Sun Java Wireless Toolkit 2.5.2_01 for CLDC Download. Disponível em:
<http://www.oracle.com/technetwork/java/download-135801.html>.
Acessado
em:
Disponível
em:
25/10/2010.
ORACLE,
Java
ME
Technology
-
CLDC.
<http://www.oracle.com/technetwork/java/javame/tech/cldc-jsp-141864.html>. Acessado em:
09/05/2011
ORACLE, Applets. Disponível: < http://java.sun.com/applets/>. Acessado em> 25/05/2011
ORACLE,
java.awt
(Java
2
Plataform
SE
v1.4.2).
Disponível
em:
<
http://download.oracle.com/javase/1.4.2/docs/api/java/awt/package-summary.html>.
Acessado em: 25/05/2011
ORRICO, Angelo Carneiro Araujo, Salvador - BA. Desenvolvendo uma aplicação J2ME.
Disponível
em:
<http://www.devmedia.com.br/post-2020-Desenvolvendo-uma-aplicacao-
J2ME.html> . Acessado em: 23/10/2010.
ORRICO, Angelo Carneiro Araujo, Salvador - BA. Desenvolvendo uma aplicação JME –
Parte II. Disponível em: <http://www.devmedia.com.br/space.asp?id=153854> . Acessado
em: 23/10/2010.
SANTOS, Leandro Gontijo dos, Paranavaí - PR. Web Service: acessando o banco de dados
pelo
celular
-
Dicas.
Disponível
em:
<http://www.guiadohardware.net/dicas/web-
service.html> . Acessado em: 20/10/2010.
SOARES, Luiz Fernando Gomes. Redes de Computadores. São Paulo: Campus, 1995.
7. Anexo 1
7.1 Diagramas
Figura 28: Diagrama de Sequência - Funcionamento Geral da Aplicação
Figura 29: Diagrama de Caso de Uso
42
Figura 30: Diagrama de Classe - Pessoa
Figura 31: Diagrama de Estrutura de Dados - Pessoa
43
7.2 Telas no Smartphone Nokia N95
Sistema Operacional: Symbian
Resolução da tela: 240 x 320px
Conectividade: WiFi, Bluetooth, WAP e 3G
Java Integrado: sim
Fonte: http://www.nokia.com.br/produtos/celulares/nokia-n95-/especificacoes-tecnicas
Figura 32: NOKIA N95 - Imagem do
Celular Pedindo acesso à rede Wi-Fi.
Figura 33: NOKIA N95 - Escolha da rede
Wi-Fi
44
Figura 34: NOKIA N95 - Lista de Dados
Figura 35: NOKIA N95 - Escolhendo a
retornados da consulta ao bancos
opção de Inserir um Novo Registro
Figura 36: NOKIA N95 - Tela de Inserção
Figura 37: NOKIA N95 - Dados inseridos
de Dados
na tela
45
Figura 38: NOKIA N95 - Gravando os
dados inseridos, no banco de dados
Figura 39: NOKIA N95 - Lista Atualizada
com o novo registro inserido
Figura 40: NOKIA N95 - Escolhendo
Figura 41: NOKIA N95 - Tela Atualizada
opção de exclusão.
após exclusão de arquivo
46
7.3 Telas no Nokia N78
Resolução da tela: 240 x 320 pixels
Conectividade: WLAN67 IEEE802.11 b/g com suporte UpnP
Java Integrado: sim
Fonte: http://www.nokia.com.br/produtos/celulares/nokia-n78/especificacoes-tecnicas
Figura 42: NOKIA N78 - Imagem do
Celular Pedindo acesso à rede Wi-Fi
Figura 43: NOKIA N78 - Dados inseridos
na tela
47
Figura 44: NOKIA N78 - Escolhendo a
Figura 45: NOKIA N78 - Escolhendo a
opção de Gravar os dados inseridos na tela
opção de Excluir os dados no banco de
no banco de dados.
dados.
48
7.4 Telas no Smartphone SAMSUNG WAVE 525
Sistema Operacional: Bada
Resolução da tela : 240 x 400 pixels
Tamanho da tela: 3.2"
Conectividade: WiFi, Bluetooth e WAP
Java Integrado: sim
Fonte: http://www.samsung.com/br/consumer/cellular-phone/cellular-phone/smartphones/GTS5250HKLZTO/index.idx?pagetype=prd_detail&returnurl
Figura 47: SANSUMG WAVE 525- Lista
Figura 46: SANSUMG WAVE 525Imagem do Celular Pedindo acesso à rede
Wi-Fi.
de Dados retornados da consulta ao banco
49
Figura 49: SANSUMG WAVE 525- Lista
Figura 48: SANSUMG WAVE 525- Dados
atualizada com as informações do banco de
inseridos na tela
dados
50
Figura 50: SANSUMG WAVE 525Escolhendo a opção de Inserir um Novo
Figura 51: SANSUMG WAVE 525- Tela
Registro
de Inserção de Dados
51
7.5 Fotos da Apresentação do Pré-Projeto
Figura 52: Imagem da Apresentação da Aplicação modelo, celular conectado ao computador
Figura 53: Imagem do Celular conectado ao Notebook e um monitor espelhando a imagem do
notebook.
52
Figura 54: Aluna Jaline mostrando o funcionamento do sistema
Figura 55: Imagem da Apresentação da Aplicação desenvolvida.
8. Anexo 2
O programa
Pessoa.java
import java.util.Vector;
import javax.microedition.lcdui.Alert;
import javax.microedition.lcdui.AlertType;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Form;
import javax.microedition.lcdui.List;
import javax.microedition.lcdui.TextField;
import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;
public class Pessoa extends MIDlet implements CommandListener{
private Vector vetorDados;
private Display display;
private AcessoWeb acessoWeb;
private List lista; //irá retornar uma lista dos resultados do banco
private Form formPessoa;
private TextField tfNome,tfFone;
private Command
cmSair,cmNovo,cmExcluir,cmGravar,cmAlterar,cmVoltar,cmRecarregar;
private boolean novoRegistro = true;
String nomePessoa="",fonePessoa="";
public Pessoa() {
}
protected void startApp() throws MIDletStateChangeException {
display = Display.getDisplay(this);//cria as configurações de tela do celular
lista = new List("Lista de Pessoas", List.EXCLUSIVE);
acessoWeb = new AcessoWeb(this);
54
formPessoa = new Form("Cadastro de Pessoa");
cmSair = new Command("Sair", Command.EXIT, 1);
cmNovo = new Command("Novo", Command.SCREEN, 1);
cmExcluir = new Command("Excluir", Command.SCREEN, 2);
cmAlterar = new Command("Alterar", Command.SCREEN, 3);
cmRecarregar = new Command("Atualizar", Command.SCREEN, 4);
cmGravar = new Command("Gravar", Command.SCREEN, 1);
cmVoltar = new Command("Voltar", Command.SCREEN, 2);
tfNome = new TextField("Nome", "", 50, TextField.ANY);
tfFone = new TextField("Telefone", "", 8, TextField.DECIMAL);
lista.addCommand(cmSair);
lista.addCommand(cmNovo);
lista.addCommand(cmExcluir);
lista.addCommand(cmAlterar);
lista.addCommand(cmRecarregar);
formPessoa.append(tfNome);
formPessoa.append(tfFone);
formPessoa.addCommand(cmGravar);
formPessoa.addCommand(cmVoltar);
lista.setCommandListener(this);
formPessoa.setCommandListener(this);
display.setCurrent(lista);
acessoWeb.lerPessoa();
}
protected void destroyApp(boolean arg0) throws MIDletStateChangeException {
}
protected void pauseApp() {
}
public void commandAction(Command c, Displayable d) {
if (c == cmSair){
try {
55
destroyApp(true);
} catch (MIDletStateChangeException e) {
e.printStackTrace();
}
notifyDestroyed();
}
else if(c == cmNovo){
novoRegistro = true;
display.setCurrent(formPessoa);
formPessoa.setTitle("Inserir Pessoa");
tfNome.setString("");
tfFone.setString("");
}
else if(c == cmVoltar){
display.setCurrent(lista);
}
else if(c == cmGravar){
if(novoRegistro){
acessoWeb.inserirPessoa(tfNome.getString(),
tfFone.getString());
} else {
acessoWeb.alterarPessoa(tfNome.getString(),
tfFone.getString(),nomePessoa, fonePessoa);
}
}
else if(c == cmRecarregar){
recarregaLista();
display.setCurrent(new Alert("Sucesso", "Atualizado com Sucesso!",
null, AlertType.ALARM));
}
else if(c == cmExcluir){
acessoWeb.excluirPessoa(lista.getString(lista.getSelectedIndex()));
}
else if(c == cmAlterar){
novoRegistro = false;
String nomeFone = lista.getString(lista.getSelectedIndex());
56
nomePessoa = nomeFone.substring(0,nomeFone.indexOf(" - "));
fonePessoa = nomeFone.substring(nomeFone.indexOf(" - ")+3);
tfNome.setString(nomePessoa);
tfFone.setString(fonePessoa);
display.setCurrent(formPessoa);
formPessoa.setTitle("Alteração de Pessoa");
}
}
public void recebeDadosPessoa(Vector vetorDados){
this.vetorDados = vetorDados;
int tamanho = vetorDados.size();
for (int i=0;i<tamanho;i++){
String[] dados = (String[]) vetorDados.elementAt(i);
lista.append(dados[1]+" - "+dados[2], null);
}
}
public void resultadoInserePessoa(int caracterLido){
if(caracterLido == 's'){
display.setCurrent(new Alert("Informação","Gravação Realizada com
Sucesso!",null,AlertType.INFO));
lista.append(tfNome.getString()+" - "+tfFone.getString(), null);
display.setCurrent(lista);
}else{
if(caracterLido == 'e'){
display.setCurrent(new Alert("Informação","NOME e TEL já
existem!",null,AlertType.ERROR));
display.setCurrent(lista);
} else {
display.setCurrent(new Alert("Informação","Não foi Possível
Gravar!",null,AlertType.ERROR));
display.setCurrent(lista);
}
}
}
public void resultadoExcluirPessoa(int caracterLido){
if(caracterLido == 's'){
57
display.setCurrent(new Alert("Informação","Exclusão Realizada com
Sucesso!",null,AlertType.INFO));
lista.delete(lista.getSelectedIndex());
display.setCurrent(lista);
}else{
display.setCurrent(new Alert("Informação","Não foi Possível
Excluir",null,AlertType.ERROR));
}
}
public void resultadoAlterarPessoa(int caracterLido){
if(caracterLido == 's'){
display.setCurrent(new Alert("Informação","Alteração Realizada com
Sucesso!",null,AlertType.INFO));
recarregaLista();
display.setCurrent(lista);
}else{
display.setCurrent(new Alert("Informação","Não foi Possível
Alterar",null,AlertType.ERROR));
}
}
public void recarregaLista(){
lista.deleteAll();
acessoWeb.lerPessoa();
}
}
58
AcessoWeb.java
import java.io.IOException;
import java.io.InputStream;
import java.util.Vector;
import javax.microedition.io.Connector;
import javax.microedition.io.HttpConnection;
import javax.microedition.io.SocketConnection;
import com.sun.kvem.io.j2me.serversocket.Socket;
public class AcessoWeb implements Runnable {
private Vector vetorDados;
private HttpConnection objConexaoHttp;
private String url;
private InputStream objInputStream;
private Pessoa objPessoa;
private Thread thread;
private String acao = "lerPessoa";
//JSP
//private String uri = "http://localhost:8080/ModeloWeb/";
//private String ext = ".jsp";
//PHP
//private String uri = "http://localhost/www/monografia/";
private String uri = "http://leandrosazevedo.info/monografia/";
private String ext = ".php";
public AcessoWeb(Pessoa objPessoa){
this.objPessoa = objPessoa;
}
public void lerPessoa(){
acao = "lerPessoa";
59
url = uri+"listaPessoas"+ext;
iniciaThread();
}
public String modificaEspaco(String p){
return p = p.substring(0,p.indexOf(' '))+"%20"+p.substring(p.indexOf(' ')+1);;
}
public void excluirPessoa(String nomeFone){
acao = "excluirPessoa";
String nomePessoa="",fonePessoa="";
nomePessoa = nomeFone.substring(0,nomeFone.indexOf(" - "));
fonePessoa = nomeFone.substring(nomeFone.indexOf(" - ")+3);
while(nomePessoa.indexOf(' ') != -1){
nomePessoa = modificaEspaco(nomePessoa);
}
while(fonePessoa.indexOf(' ') != -1){
fonePessoa = modificaEspaco(fonePessoa);
}
url =
uri+"excluirPessoa"+ext+"?nomePessoa="+nomePessoa+"&telefonePessoa="+fonePessoa;
iniciaThread();
}
public void alterarPessoa(String novoNome,String novoTelefone,String
antigoNome,String antigoTelefone){
acao = "alterarPessoa";
while(novoNome.indexOf(' ') != -1){
novoNome = modificaEspaco(novoNome);
}
while(antigoNome.indexOf(' ') != -1){
antigoNome = modificaEspaco(antigoNome);
}
url =
uri+"alterarPessoa"+ext+"?novoNomePessoa="+novoNome+"&novoTelefonePessoa="+novo
Telefone+"&nomePessoa="+antigoNome+"&telefonePessoa="+antigoTelefone;
60
iniciaThread();
}
public void inserirPessoa(String nomePessoa, String telefonePessoa){
acao = "inserePessoa";
while(nomePessoa.indexOf(' ') != -1){
nomePessoa = modificaEspaco(nomePessoa);
}
url =
uri+"inserirPessoa"+ext+"?nomePessoa="+nomePessoa+"&telefonePessoa="+telefonePessoa
;
iniciaThread();
}
public void run() {
System.out.println("Inicando o public void run()");
try{
if(acao.equals("lerPessoa")){
System.gc();//limpa dados vazios de objetos na memória
vetorDados = new Vector();//ira armazenar os dados para jogar
na tela do celular
String[] dados;
objConexaoHttp = (HttpConnection) Connector.open(url);
if(objConexaoHttp.getResponseCode() ==
HttpConnection.HTTP_OK){
objInputStream =
objConexaoHttp.openInputStream();//todo o conteudo resultado da pesquisa da url
System.out.println("Http OK");
int i = 1, caracterLido = objInputStream.read();//retorna
de 0 a 255 na tabela ascii
StringBuffer stringBuffer = new StringBuffer();
while(caracterLido != '@'){
dados = new String[3];
while(caracterLido != ','){//lendo o codigo da
pessoa
stringBuffer.append((char) caracterLido);
61
caracterLido = objInputStream.read();
}
System.out.println("Código =
"+stringBuffer.toString().trim());
dados[0] = stringBuffer.toString().trim();
stringBuffer.delete(0,
stringBuffer.length());//limpando para nao acumular
caracterLido = objInputStream.read();
while(caracterLido != ','){//lendo o nome da
pessoa
stringBuffer.append((char) caracterLido);
caracterLido = objInputStream.read();
}
System.out.println("Nome =
"+stringBuffer.toString().trim());
dados[1] = stringBuffer.toString().trim();
stringBuffer.delete(0,
stringBuffer.length());//limpando para nao acumular
caracterLido = objInputStream.read();
while(caracterLido != '#'){//Lendo o telefone da
pessoa
stringBuffer.append((char) caracterLido);
caracterLido = objInputStream.read();
}
System.out.println("Telefone =
"+stringBuffer.toString().trim());
dados[2] = stringBuffer.toString().trim();
stringBuffer.delete(0, stringBuffer.length());
caracterLido = objInputStream.read();
vetorDados.addElement(dados);
}
objPessoa.recebeDadosPessoa(vetorDados);
objInputStream.close();
System.gc();
}
62
}
else if(acao.equals("inserePessoa")){
objConexaoHttp = (HttpConnection) Connector.open(url);
if(objConexaoHttp.getResponseCode() ==
HttpConnection.HTTP_OK){
System.gc();
System.out.println("Http OK no Insere Pessoa");
objInputStream =
objConexaoHttp.openInputStream();//todo o conteudo resultado da pesquisa da url
int caracterLido = objInputStream.read();
while(caracterLido != '@'){
if(caracterLido == 10){
caracterLido = objInputStream.read();
continue;
}
objPessoa.resultadoInserePessoa(caracterLido);
caracterLido = objInputStream.read();
}
objInputStream.close();
System.gc();
}
}
else if(acao.equals("excluirPessoa")){
objConexaoHttp = (HttpConnection) Connector.open(url);
if(objConexaoHttp.getResponseCode() ==
HttpConnection.HTTP_OK){
System.gc();
System.out.println("Http OK no Excluir Pessoa");
objInputStream =
objConexaoHttp.openInputStream();//todo o conteudo resultado da pesquisa da url
int caracterLido = objInputStream.read();
while(caracterLido != '@'){
if(caracterLido == 10){
caracterLido = objInputStream.read();
continue;
}
63
objPessoa.resultadoExcluirPessoa(caracterLido);
caracterLido = objInputStream.read();
}
objInputStream.close();
System.gc();
}
}
else if(acao.equals("alterarPessoa")){
objConexaoHttp = (HttpConnection) Connector.open(url);
if(objConexaoHttp.getResponseCode() ==
HttpConnection.HTTP_OK){
System.gc();
System.out.println("Http OK no Alterar Pessoa");
objInputStream = objConexaoHttp.openInputStream();
int caracterLido = objInputStream.read();
while(caracterLido != '@'){
if(caracterLido == 10){
caracterLido = objInputStream.read();
continue;
}
objPessoa.resultadoAlterarPessoa(caracterLido);
caracterLido = objInputStream.read();
}
objInputStream.close();
System.gc();
}
}
}
catch (IOException io) {
System.out.println("Erro de IOException "+io);
}
catch (SecurityException se) {
System.out.println("Erro de SecurityException "+se);
}
}
64
public void iniciaThread(){
System.out.println("Inicia Thread");
thread = new Thread(this);
thread.start();
System.out.println("Startou a Thread");
}
}
65
inserirPessoa.jsp
<%@page import="com.sun.corba.se.spi.orbutil.fsm.Guard.Result"%>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF8"%>
<%@ page import="java.sql.*"%>
<%
String driver = "org.postgresql.Driver";
String url = "jdbc:postgresql://localhost:5432/estoque";
String usuario = "postgres";
String senha = "senha";
Connection conexao;
Statement statement;
ResultSet resultSet;
try {
Class.forName(driver).newInstance();
conexao = DriverManager.getConnection(url,usuario,senha);
statement = conexao.createStatement();
String sql = "insert into pessoa (nome,telefone) values
('"+request.getParameter("nomePessoa")+"','"+request.getParameter("telefonePessoa")+"')";
int gravou = statement.executeUpdate(sql);// 0 ou 1
if(gravou == 1){
out.print("s@");
System.out.println("IP do CLIENTE: "+request.getRemoteAddr());
}else{
out.print("f@");
}
}
catch(Exception e){
out.print(e+"f@");
}
%>
66
alterarPessoa.jsp
<%@ page import="com.sun.corba.se.spi.orbutil.fsm.Guard.Result"%>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF8"%>
<%@ page import="java.sql.*"%>
<%
String driver = "org.postgresql.Driver";
String url = "jdbc:postgresql://localhost:5432/estoque";
String usuario = "postgres";
String senha = "senha";
Connection conexao;
Statement statement;
ResultSet resultSet;
try {
Class.forName(driver).newInstance();
conexao = DriverManager.getConnection(url, usuario, senha);
statement = conexao.createStatement();
String sql = "UPDATE pessoa SET nome = '"
+ request.getParameter("novoNomePessoa")
+ "', telefone = '"
+ request.getParameter("novoTelefonePessoa")
+ "' WHERE nome = '"
+ request.getParameter("nomePessoa")
+ "' AND telefone = '"
+ request.getParameter("telefonePessoa") + "'";
int excluiu = statement.executeUpdate(sql);// 0 ou 1
if (excluiu == 1) {
out.print("s@");
} else {
out.print("f@");
}
} catch (Exception e) {
out.print(e + "f@");
} %>
67
listaPessoa.jsp
<%@page import="com.sun.corba.se.spi.orbutil.fsm.Guard.Result"%>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF8"%>
<%@ page import="java.sql.*"%>
<%
String driver = "org.postgresql.Driver";
String url = "jdbc:postgresql://localhost:5432/estoque";
String usuario = "postgres";
String senha = "senha";
Connection conexao;
Statement statement;
ResultSet resultSet;
try {
Class.forName(driver).newInstance();
conexao = DriverManager.getConnection(url,usuario,senha);
statement = conexao.createStatement();
resultSet = statement.executeQuery("select * from pessoa");
String listaDados = "";
while(resultSet.next()){
out.print(resultSet.getInt(1));
out.print(","+resultSet.getString(2));
out.print(","+resultSet.getString(3)+"#");
}
}
catch(ClassNotFoundException Driver){
out.print("Driver não Localizado: "+Driver);
}
catch(SQLException Fonte){
out.print("Deu erro de conexao com a fonte de dados: "+Fonte);
}
out.print("@");
System.out.println("o celular me acessou!");
%>
68
excluirPessoa.jsp
<%@page import="com.sun.corba.se.spi.orbutil.fsm.Guard.Result"%><%@ page
language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ page import="java.sql.*"%>
<%
String driver = "org.postgresql.Driver";
String url = "jdbc:postgresql://localhost:5432/estoque";
String usuario = "postgres";
String senha = "senha";
Connection conexao;
Statement statement;
ResultSet resultSet;
try {
Class.forName(driver).newInstance();
conexao = DriverManager.getConnection(url,usuario,senha);
statement = conexao.createStatement();
String sql = "delete from pessoa where nome =
'"+request.getParameter("nomePessoa")+"' AND telefone =
'"+request.getParameter("telefonePessoa")+"'";
int excluiu = statement.executeUpdate(sql);// 0 ou 1
if(excluiu == 1){
out.print("s@");
}else{
out.print("f@");
}
}
catch(Exception e){
out.print(e+"f@");
}
%>