KATIA GOMES DA SILVA
COMPARATIVO ENTRE AS PLATAFORMAS J2ME E .NET
COMPACT FRAMEWOK PARA DESENVOLVIMENTO DE
APLICAÇÕES PARA DISPOSITIVOS MÓVEIS
Palmas – TO
2006
2
KATIA GOMES DA SILVA
COMPARATIVO ENTRE AS PLATAFORMAS J2ME E .NET
COMPACT FRAMEWOK PARA DESENVOLVIMENTO DE
APLICAÇÕES PARA DISPOSITIVOS MÓVEIS
“Trabalho de apresentado como
requisito da disciplina Trabalho de
Conclusão de Curso em Sistemas
de Informação I e II do curso de
Sistemas
de
Informação,
orientado pelo Prof. M. Sc.
Fernando Luiz de Oliveira”.
Palmas – TO
2006
3
KATIA GOMES DA SILVA
COMPARATIVO ENTRE AS PLATAFORMAS J2ME E .NET
COMPACT FRAMEWOK PARA DESENVOLVIMENTO DE
APLICAÇÕES PARA DISPOSITIVOS MÓVEIS
“Trabalho
apresentado
como
requisito da disciplina Trabalho de
Conclusão de Curso em Sistemas
de Informação I e II do curso de
Sistemas
de
Informação,
orientado pelo Prof. M. Sc.
Fernando Luiz de Oliveira”.
BANCA EXAMINADORA
_____________________________________________
Prof. M. Sc. Fernando Luiz de Oliveira
Centro Universitário Luterano de Palmas
_____________________________________________
Profª. M. Sc. Madianita Bogo
Centro Universitário Luterano de Palmas
_____________________________________________
Prof. M. Sc. Ricardo Marx Costa Soares de Jesus
Centro Universitário Luterano de Palmas
Palmas - TO
2006
4
AGRADECIMENTO
A Deus, que me acompanha em todos os momentos da minha vida,
proporcionando-me força, paz e esperança.
Aos meus pais, Benedito e Sonimar, que estiveram sempre ao meu lado,
apoiando-me, incentivando-me nos meus estudos e formação intelectual e moral.
Amo vocês.
Ao meu irmão, Kássio, que me acompanhou e auxiliou-me nos momentos mais
necessários.
Ao Igor, pelo constante incentivo, pela paciência e carinho.
Aos meus familiares, em especial, aos meus avós, Antônio (in memoriam) e Nice
(in memoriam): fontes eternas de inspiração.
Ao meu orientador, Prof. Fernando Luiz de Oliveira, pela atenção e dedicação no
desenvolvimento deste trabalho.
A todos os professores, que me fizeram enxergar o mundo da informação,
conhecimento e tecnologia.
Aos meus amigos e as SMAs, pela companhia, força, amizade, pelos momentos
de alegria e tristeza.
E a todos aqueles que, direta ou indiretamente, contribuíram para a realização
deste trabalho.
5
SUMÁRIO
1. INTRODUÇÃO................................................................................................ 12
2. REVISÃO DA LITERATURA........................................................................... 14
2.1 Aplicações para dispositivos móveis ............................................................ 14
2.2 Tecnologia .NET........................................................................................... 16
2.2.1
.NET para programação para dispositivos móveis.................................. 16
2.2.2
.NET Compact Framework...................................................................... 17
2.3 Tecnologia Java ........................................................................................... 17
2.3.1
Linguagem Java...................................................................................... 19
2.3.2
API .......................................................................................................... 20
2.3.2
JVM......................................................................................................... 20
2.4 Tecnologia Java para programação para dispositivos móveis ..................... 21
2.4.1
J2ME....................................................................................................... 21
2.4.2
Perfil........................................................................................................ 22
2.4.3
Configuração........................................................................................... 24
2.4.4
APIs opcionais ........................................................................................ 28
2.4.5
Máquina virtual........................................................................................ 29
2.5 Web Services ............................................................................................... 29
2.5.1
A utilização de Web Services pela plataforma Java ............................... 30
2.5.2
A utilização de Web Services pela plataforma .NET............................... 31
2.5 Exemplificação da Integração das Tecnologias ........................................... 33
3. MATERIAIS E MÉTODOS .............................................................................. 42
3.1 Local e Período ............................................................................................ 42
3.2 Materiais....................................................................................................... 42
3.2.1
Hardware ................................................................................................ 42
3.2.2
Software.................................................................................................. 43
3.2.3
Fontes Bibliográficas............................................................................... 43
3.3 Metodologia.................................................................................................. 43
4. RESULTADOS E DISCUSSÕES.................................................................... 44
4.1 Arquitetura das plataformas .NET CF e J2ME ............................................. 44
4.2 Biblioteca de classe das plataformas .NET CF e J2ME ............................... 46
6
4.3 Processo de desenvolvimento de aplicações nas plataformas .NET CF e
J2ME .................................................................................................................... 50
4.3.1
Ferramentas de desenvolvimento........................................................... 50
4.3.2
Ambiente de execução ........................................................................... 51
5. CONSIDERAÇÕES FINAIS ............................................................................ 56
7
LISTA DE FIGURAS
Figura 1 - Arquitetura Java, modificada de (SUN, 2005a) ................................... 18
Figura 2 - Modelo de desenvolvimento em camadas da J2ME, modificada de
(CARDOSO, 2005)............................................................................................... 22
Figura 3 – Elementos das APIs da configuração CLDC ...................................... 26
Figura 4 – Elementos das APIs da configuração CLDC ...................................... 27
Figura 5 – Elementos das APIs da configuração CLDC ...................................... 27
Figura 6 – Camadas de desenvolvimento de aplicações .NET e Java (OLIVEIRA,
2004) .................................................................................................................... 32
Figura 7 – Esquema navegacional ...................................................................... 33
Figura 8 - Tela da página inicial da aplicação...................................................... 34
Figura 9 – Código de implementação das funções do menu............................... 35
Figura 10 – Seqüência da consulta por número .................................................. 36
Figura 11 – Métodos do Web Service ................................................................. 37
Figura 12 – Janela para inserção do método consultarPorNumero..................... 38
Figura 13 – Resultado da execução do método consultarPorNumero ................ 39
Figura 14 – Código da classe de conexão com o Web Service........................... 40
Figura 15 - Código do método de consulta por número ...................................... 41
Figura 16 - Arquitetura J2ME usando a CLDC .................................................... 45
Figura 17 – Arquitetura da .NET Compact Framework........................................ 45
Figura 18 – Código do controle TextBox ............................................................. 47
Figura 19 – Código do controle TextField............................................................ 48
Figura 20 – Código dos KSOAP e KXML ............................................................ 48
Figura 21 – Código da classe Web Service......................................................... 49
Figura 22 - Ciclo de execução da aplicação .NET CF ......................................... 52
Figura 23 - Ciclo de execução da aplicação J2ME.............................................. 53
8
LISTA DE TABELAS
Tabela 1 – Classes de Interface (MSDN, 2003 e SUN, 2004b) ........................... 46
Tabela 2 – Classes de Entrada e Saída (MSDN, 2003 e SUN, 2004b) ............... 49
Tabela 3 – Tabela de comparativo entre as plataformas .NET CF e J2ME ......... 54
9
LISTA DE ABREVIATURAS
API = Interface Programming Applications
CDC = Connected Device Configuration
CLDC = Connected Limited Device Configuration
CLR = Commom Language Runtime
CLS = Common Language Specidication
CVM = Compact Virtual Machine
FP = Foundation Profile
HTTP = Hyper Text Transfer Protocol
IL = Intermediate Language
J2EE = Java 2 Enterprise Editition
J2ME = Java 2 Micro Edition
J2SE = Java 2 Standard Edition
JAR = Java Archive
JAD = Java Application Descriptor
JDK = Java Development Kit
JVM = Java Virtual Machine
JAXP = Java API for WML Processing
JAXR = Java API for WML Registries
JAX-RPC = Java API for XML Remote Procedure Call
JIT = Just-In-Time
JNI = Java Native Interface
JWSDP = Java Web Service Develoment Pack
KSOAP = K Simple Object Access Protocol
KVM = Kilo Virtual Machine
KXML = K Wireless Makup Language
MIPD = Mobile Information Device Profile
MMAPI = Mobile Media API
MSIL = Microsoft Intermediate Language
.NET CF = .NET Compact Framework
PBP = Personal Basis Profile
10
PP = Personal Profile
PDA = Personal Digital Assistants
RPC = Remote Procedure Call
SAAJ = SOAP with Attachments API for Java
SMS = Short Message Service
SOAP = Simple Object Access Protocol
UDDI = Universal Description, Discovery, and Integration
WAP = Wireless Application Protocol
WMA = Wireless Messaging API
WML = Wireless Makup Language
WSDL = Web Services Description Language
XML = Extensive Mark up Language
11
RESUMO
Com o crescente mercado de dispositivos móveis, cresce também a
competitividade
entre
as
empresas
que
oferecem
serviços
para
o
desenvolvimento de aplicações móveis. Este trabalho apresenta um comparativo
entre as plataformas .NET Compact Framework e J2ME para o desenvolvimento
de aplicações para dispositivos móveis. O comparativo tem por base os estudos
sobre as características gerais das duas plataformas, destas são abordados os
recursos, serviços, suporte a Web Services, ferramentas de desenvolvimento,
processamento e ainda, o desenvolvimento de um exemplo de aplicação J2ME.
Palavras-chave: Dispositivos Móveis, Plataforma .NET Compact Framework,
Plataforma J2ME.
12
1.
INTRODUÇÃO
Existem diversas tecnologias para desenvolvimento de aplicações para
dispositivos móveis. Por ser assim, no momento da definição das tecnologias a
serem utilizadas, deve-se analisar a plataforma de desenvolvimento, uma vez que
existem
diversas
plataformas,
baseadas
em
diferentes
linguagens
de
programação e com uma variedade de ferramentas, que oferecem recursos que
permitem integrar vários aplicativos, como: Java, com sua versão para
dispositivos móveis a Java 2 Micro Edition (J2ME) e .NET, com a versão .NET
Compact Framework (.NET CF). Deve-se levar em consideração critérios que
permitam uma escolha da plataforma mais adequada ao tipo de aplicação a ser
desenvolvida, por exemplo, característica do dispositivo utilizado, tamanho,
facilidades, desempenho, custo e velocidade de desenvolvimento.
Este trabalho estuda e analisa as plataforma .NET e Java no
desenvolvimento de aplicações para dispositivos móveis. Isto implica em estudar
as características de desenvolvimento de uma aplicação utilizando estas referidas
plataformas. No entanto, parte deste trabalho refere-se ao trabalho de estágio
realizado anteriormente em Silva (2006), que servirá para exemplificar o
desenvolvimento de aplicações móveis na plataforma .NET. Para exemplificar o
desenvolvimento de aplicações móveis usando o J2ME, será desenvolvida uma
aplicação
responsável
por
apresentar
o
resultado
do
vestibular
do
CEULP/ULBRA, localizado em um banco de dados remoto, o qual será acessado
por meio de métodos de um Web Service que, por sua vez, é o mesmo utilizado
no trabalho de Silva (2006), e que foi desenvolvido na plataforma .NET. Desta
forma, será realizada a implementação de uma aplicação de armazenamento,
busca e acesso a base de dados.
13
Após o estudo das plataformas .NET Compact Framewok e J2ME, este
trabalho
tem
como
objetivo
realizar
um
comparativo
entre
elas
no
desenvolvimento de aplicações para dispositivos móveis, a fim de oferecer
informações acerca de suas características, recursos, configurações, linguagens,
classes, componentes, serviços, suporte a Web Services, facilidades e elementos
de desenvolvimento, como: interface com o usuário, processamento, entre outras
informações.
Este trabalho está estruturado em capítulos, divididos da seguinte forma: o
capítulo 2 apresenta uma visão geral sobre os dispositivos móveis, as plataformas
.NET e Java utilizadas para o desenvolvimento de aplicações para dispositivos
móveis, uma breve descrição de Web Services, assim como a utilização da
plataforma J2ME e seus componentes no desenvolvimento de uma aplicação e os
passos seguidos para seu desenvolvimento. O capítulo 3 apresenta os materiais e
métodos utilizados para o desenvolvimento deste trabalho. Já o capítulo 4
apresenta um comparativo entra as plataformas .NET Compact Framework e
J2ME no desenvolvimento de aplicações móveis. Em seguida, o capítulo 5
apresenta as considerações finais sobre o trabalho. Por fim, no capítulo 6 são
apresentadas as referências bibliográficas utilizadas.
14
2.
REVISÃO DA LITERATURA
Para o desenvolvimento deste trabalho foram realizadas pesquisas e estudos
sobre desenvolvimento de aplicações para dispositivos móveis, assim como uma
breve descrição da tecnologia .NET para programação de aplicações para
dispositivos móveis, tecnologia Java, plataforma J2ME, programação para
dispositivos utilizando a plataforma J2ME e Web Services. Estes estudos foram
necessários para que se realizasse um comparativo entre as plataformas .NET e
Java no desenvolvimento de aplicações para dispositivos móveis, a fim de
atender os objetivos deste trabalho. Esses estudos estão disponibilizados nas
seções seguintes.
2.1 Aplicações para dispositivos móveis
A necessidade que as pessoas passaram a ter em acessar informações e
serviços a qualquer hora e em qualquer lugar fez surgir uma nova tecnologia, a
computação móvel (HADDAD, 2002). A computação móvel permite ganhar
mobilidade e teve um grande avanço tecnológico devido ao fato da evolução dos
aparelhos celulares, que deixaram de ser um simples mecanismo de
comunicação de voz, e passaram a ter um conjunto de funções pré-determinadas,
atuando como assistentes pessoais.
Os dispositivos móveis podem ser facilmente levados a qualquer lugar,
tendo sido criados para atender usuários em movimento que necessitam de
rapidez e segurança no acesso a informações, que integram funcionalidades
como: agenda pessoal, envio/recebimento de dados, manipulação de arquivos de
mídia, fotografias e execução de aplicativos. Assim, os usuários podem executar
15
programas que vão desde jogos, até aplicativos corporativos e pessoais, entre
outras variedades, permitindo aos usuários customizar seus dispositivos com
novos serviços e recursos.
Estas operações são viáveis por meio de dispositivos móveis, que podem
ser classificados como:
•
Celulares: são dispositivos de comunicação de voz e dados. Oferecem
serviços de envio/recebimento de mensagem de dados e multimídia. Com o
surgimento da tecnologia WAP (Wireless Application Protocol), ou protocolo
para aplicações sem fio, permitiu a visualização de páginas da internet em
dispositivos móveis (celulares) (WAP, 2004).
•
PDAs (Personal Digital Assistants): dispositivos que incorporam funções de
um computador, porém, com processamento reduzido. Existem algumas
funções como agenda pessoal, blocos de notas, gerenciador de contatos,
acesso à internet, arquivos de mídia, gravador de voz, entre outros recursos.
Na maioria dos casos não possuem teclados nem mouse e a entrada dos
dados é feita através de uma caneta, chamada de stylus (MIRANDA, 2004).
•
SmartPhones: correspondem a um telefone celular que possui atributos dos
PDA´s, como maior capacidade de memória e processamento, recursos de
expansibilidades e facilidades de acesso à internet (MIRANDA, 2004). Estes
dispositivos foram planejados para serem usados da mesma maneira que um
celular, porém, com os recursos técnicos disponíveis em um PDA, reunindo a
mobilidade do primeiro e a capacidade de processamento do segundo.
•
Pager: pequeno dispositivo móvel que permite enviar/receber sinais de aviso e
mensagens, ou seja, um bipe eletrônico.
Com a vasta utilização destes dispositivos, nota-se uma procura crescente
para o desenvolvimento de aplicativos para dispositivos móveis, tanto para uso
próprio, como para uso comercial. Existe uma variedade de tecnologias que
facilitam a comunicação através de dispositivos sem fios, assim como para o
desenvolvimento de aplicações para dispositivos móveis. São tecnologias como: a
plataforma Java com sua versão para dispositivos móveis, a J2ME (Java 2 Micro
Edition), e a plataforma .NET que possui uma versão simplificada, a .NET
16
Compact Framework. As seções a seguir apresentarão com mais detalhes cada
uma destas tecnologias.
2.2 Tecnologia .NET
A tecnologia .NET possui uma plataforma única, que constitui um ambiente de
desenvolvimento e execução de aplicações, que vão de uso pessoal ao
coorporativo. Caracteriza-se pela facilidade de desenvolvimento dos serviços
Web, a disponibilidade dos serviços de execução de diversas linguagens de
programação e pela interoperabilidade entre linguagens e sistemas operacionais
(MSDN, 2003). Assim, uma das características mais importantes da .NET é a
independência de plataforma e de uma linguagem específica, exigindo apenas
que essas linguagens sejam compatíveis com a especificação do .NET para o
desenvolvimento.
2.2.1 .NET para programação para dispositivos móveis
Uma tecnologia importante da .NET é a ASP.NET, que possibilita o
desenvolvimento de aplicações para Web, ou seja, as informações ficam
armazenadas na internet e não mais apenas em uma máquina. Uma aplicação
criada em ASP.NET para ser acessada na Internet é semelhante à de uma
aplicação ASP.NET para dispositivos móveis, por exemplo, um celular, possuindo
inclusive a mesma extensão (.aspx). No entanto, internamente estas aplicações
possuem características diferentes (AVELINO, 2004).
O ASP.NET suporta o desenvolvimento de aplicações em qualquer
linguagem compatível com o .NET. Essas aplicações Web podem ser executadas
no navegador de um dispositivo móvel. Assim, podem ser acessadas de qualquer
PDA, celular ou SmartPhone, podendo ser integradas entre diversos aplicativos. A
.NET oferece, ainda, uma tecnologia para o desenvolvimento de aplicações para
dispositivos móveis, a .NET Compact Framework, apresentada na próxima seção.
17
2.2.2 .NET Compact Framework
A .NET Compact Framework tem por objetivo oferecer um ambiente de
desenvolvimento para sistemas que sejam executados em dispositivos móveis,
tais como os celulares, SmartPhones, PDAs, Pocket PCs e outros aparelhos, com
recursos limitados (GALVIN, 2004).
A .NET Compact Framework (.NET CF) é uma versão simplificada da .NET
(MSDN, 2003). Este fato proporcionou aos desenvolvedores uma facilidade no
desenvolvimento de aplicações para dispositivos móveis, pois podem reutilizar
experiências e conhecimentos adquiridos na implementação de aplicações para
desktop ou aplicações web comuns.
A .NET Compact Framework proporciona um ambiente de desenvolvimento
em multilinguagens, ou seja, permite uma independência de linguagem no
desenvolvimento de aplicações, em que cada módulo pode ser desenvolvido em
uma linguagem suportada pela .NET, integrando várias linguagens em uma
mesma plataforma. Além disso, possui um conjunto específico de ferramentas,
desenvolvido especialmente para a implementação de aplicações em dispositivos
móveis. A .NET CF possui uma nova implementação da CLR (Common Language
Runtime), responsável por executar as aplicações em dispositivos móveis, além
de ter uma biblioteca de classes (Class Library) com menos de 50% das classes
existentes no .NET (BURÉGIO, 2003).
Para o desenvolvimento de aplicações que atuem em dispositivos móveis,
a Microsoft oferece a ferramenta Visual Studio.NET, que proporciona um
ambiente completo para desenvolvimento visual. Esta ferramenta oferece um
suporte a atividade de testes da aplicação, através dos emuladores, que simula
um dispositivo móvel real com todos os recursos que o mesmo possui. Permite,
também, o desenvolvimento de aplicações que utilizam a tecnologia Web Service,
que será apresentado na seção 2.5 deste trabalho.
2.3 Tecnologia Java
Java é uma tecnologia de desenvolvimento que vai desde o desenvolvimento de
aplicações para desktop, a aplicações para dispositivos móveis. A Sun (2005),
18
atualmente, agrupou a tecnologia Java em quatro edições diferentes: J2SE (Java
2 Standard Edition), J2EE (Java 2 Enterprise Editition), J2ME (Java 2 Micro
Edition) e JavaCard, conforme mostra a Figura 1.
Figura 1 - Arquitetura Java, modificada de (SUN, 2005a)
Cada uma dessas edições foca um segmento. O Java 2 Standard Edition
(J2SE) é a versão padrão, destinada ao desenvolvimento da maior parte das
aplicações desktop, e esta é a plataforma principal, na qual o Java 2 Enterprise
Editition (J2EE) e o Java 2 Micro Edition (J2ME) têm sua base. O J2EE é a
versão destinada ao desenvolvimento de aplicações de grande porte, ou seja,
voltada, por exemplo, para redes, Internet e intranets, contendo bibliotecas
destinadas ao desenvolvimento para o acesso a servidores, sistemas de e-mail
etc. O J2ME é uma versão compacta da linguagem Java, destinada ao
desenvolvimento de programas para dispositivos móveis, como celulares, pager´s
e PDA´s, sendo trabalhadas especialmente para atuação em dispositivos
portáteis. É necessário que estes dispositivos disponham de uma máquina virtual
Java (JVM – Java Virtual Machine), pois é esse o recurso que possibilita que o
mesmo programa rode em várias plataformas. Finalmente, JavaCard é uma
tecnologia destinada a rodar em smart cards e outros dispositivos extremamente
limitados.
Segundo a Sun (2005a), a plataforma Java é baseada, em geral, num
conjunto de elementos, como: a linguagem de programação Java, APIs (Interface
Programming Applications) e a Máquina Virtual Java – JVM. As seções seguintes
apresentam cada um destes elementos.
19
2.3.1 Linguagem Java
Segundo Alcântara & Indrusiak (2001), “Java é uma linguagem de programação
independente de plataforma, desenvolvida pela Sun Microsystems. Originalmente
feita para integrar circuitos de eletrodomésticos, ganhou a Internet, sendo
utilizada largamente na Web com objetivo de dinamizar sites e integrar
servidores”. A linguagem Java, inicialmente chamada de Oak, foi criada
especificamente
para
funcionar
em
processadores
de
eletrodomésticos
(ALCÂNTARA & INDRUSIAK, 2001), e, nesta fase, os programas eram
dependentes da plataforma para o qual eram desenvolvidos, necessitando de um
novo programa a cada evolução dos eletrodomésticos. Em razão disso, a Sun
propôs o desenvolvimento de uma linguagem que fosse independente de
plataforma. Por causa do surgimento da World Wide Web - WWW, a linguagem
Oak foi direcionada para o desenvolvimento, também, de aplicações Web, dando
origem à linguagem Java (DUKE, 2003).
Java é uma linguagem que opera em qualquer sistema operacional, sendo
orientada a objetos, independente de arquitetura, multithreaded, com coleta de
lixo (garbage collector), entre outras características (SILVEIRA, 2003). A seguir
serão explicadas algumas destas características:
•
Orientada a objetos: Java é uma linguagem de programação orientada a
objeto, sendo que a maior parte dos elementos de um programa Java são
objetos. O código é organizado em classes, cada classe define um conjunto de
propriedade e métodos que formam o comportamento de um objeto, entre
outras características.
•
Arquitetura independente: Java é uma linguagem independente, ou seja, o
desenvolvedor possui a liberdade de escolha da plataforma operacional e da
ferramenta de desenvolvimento. Possui também, uma extensa biblioteca de
classes que oferece acesso a qualquer sistema operacional.
•
Ambiente multithreaded: em um programa Java pode-se ter mais de uma linha
de execução (thread), por exemplo, cálculos extensos podem ser operados em
uma linha de execução e, paralelamente, a interface pode ser executada em
20
outra linha de execução. Java fornece diversos recursos de sincronização de
processos que tornam a programação mais simples.
•
Coletor de lixo (garbage collection): “em Java, os programadores não se
preocupam com gerenciamento de memória” (SILVA, 2001). O coletor de lixo
tem a função de percorrer a memória constantemente e automaticamente,
liberando as que não estão sendo utilizadas.
2.3.2 API
“A API (Interface de programa aplicativo) de Java consiste em um conjunto de
bibliotecas de tempo de execução que fornecem ao desenvolvedor de software
uma forma padrão de acessar os recursos do sistema” (SILVA, 2001). Uma API é
formada pelo conjunto de funções, dados, tipos, regras de uso e especificações
(GLOSSÁRIO, 2006). É um conjunto usado para realizar a comunicação de uma
determinada aplicação, o que dá aos desenvolvedores, uma forma unificada de
acessar as funcionalidades de sistemas distintos. “A API contribui não apenas
com a independência de plataforma, mas também com a segurança, isto é, possui
métodos que verificam permissões para efetuar qualquer ação em uma aplicação”
(SILVA, 2001).
2.3.2 JVM
A portabilidade do Java depende da existência de JVMs para as diversas
plataformas, baseado no conceito de que se escreva uma vez e execute em
qualquer lugar (ALECRIM, 2004), permitindo executar códigos Java em qualquer
plataforma. Por exemplo, quando se desenvolve uma aplicação para celular, com
algumas modificações é possível executar esse mesmo aplicativo em um PDA
(FONSECA, 2002). A JVM permite que os programas escritos em Java funcionem
em qualquer plataforma que possua uma versão da JVM, tornando assim essas
aplicações independentes da plataforma em que serão executadas.
21
Segundo a Sun (2004a), a JVM pode ser definida como “uma máquina
imaginária que executa instruções vindas de bytecodes”. Bytecode é um arquivo
gerado após a compilação de programas Java, que possui uma extensão
chamada ‘.class’. É um código que traduz o que foi escrito no programa Java para
um formato que a JVM entenda e execute.
A plataforma Java oferece tecnologias de desenvolvimento para aplicações
em diversos sistemas operacionais, que vão desde dispositivos móveis a
aplicativos Web. A plataforma Java dispõe do J2ME para desenvolvimento de
aplicações para dispositivos móveis e máquinas virtuais específicas para atuarem
nesses dispositivos, assunto que será mais detalhado nas próximas seções.
2.4 Tecnologia Java para programação para dispositivos móveis
Devido ao grande avanço da tecnologia para dispositivos móveis, incluindo jogos,
recursos multimídias, agenda de compromisso, acesso à internet, entre outros, a
A Sun definiu uma versão para o desenvolvimento de aplicações para dispositivos
móveis, a J2ME, independentemente de sistema operacional, dividida em:
configuração, perfil e APIs opcionais (SUN, 2004b).
2.4.1 J2ME
Segundo Almeida (2005), o objetivo desta tecnologia (J2ME) é o desenvolvimento
de aplicações em dispositivos móveis com pequeno poder de processamento,
desde telefones celulares, pagers, PDA, até smartphone e TVs. O J2ME possui
um modelo de três camadas, que são: configurações, perfis e máquina virtual
(CARDOSO, 2005), conforme mostra a Figura 2.
22
PERFIS
CONFIGURAÇÕES
MÁQUINA VIRTUAL
SISTEMA OPERACIONAL
Figura 2 - Modelo de desenvolvimento em camadas da J2ME, modificada de
(CARDOSO, 2005)
A máquina virtual está posicionada acima do sistema operacional do
dispositivo, pois é a máquina virtual a responsável por definir quais as limitações
de execução das aplicações nos dispositivos. A camada de configuração define o
nível de funcionalidades e serviços oferecidos pela máquina virtual. Por fim, o
perfil é um conjunto de bibliotecas específico para uma determinada configuração,
mas uma configuração pode suportar vários perfis. As camadas da J2ME serão
mais detalhadas nas próximas seções.
2.4.2 Perfil
O perfil é um complemento da configuração, que deve ser combinado com um
conjunto de APIs, a fim de prover um serviço mais completo para as aplicações.
Define um ambiente completo para cada tipo de dispositivo, que vão desde
recursos de um nível mais alto de interface com o usuário, a acesso às
propriedades específicas do dispositivo (PINHEIRO, 2003).
A Sun (2004a) introduziu esse conceito para prover maior flexibilidade às
mudanças tecnológicas. Cada perfil é destinado a uma categoria específica de
dispositivos e consiste em um conjunto mínimo de bibliotecas de classes que
determinado aparelho deve suportar.
Os perfis são mais específicos que as configurações, apesar de serem
baseadas nelas. A J2ME define dois tipos de configurações, que serão melhor
explicadas na seção 2.4.3: a CLDC (Connected Limited Device Configuration) e
CDC (Connected Device Configuration). Os perfis existentes para a CLDC são
23
diferentes dos existentes para CDC (SUN, 2004a). Os perfis podem ser
classificados como FP (Foundation Profile), PP (Personal Profile), PBP (Personal
Basis Profile) e MIPD (Mobile Information Device Profile), além de possuírem APIs
opcionais (PINHEIRO, 2003).
•
FP: o Foundation Profile complementa a configuração do CDC, sendo o nível
mais baixo da mesma, fornecendo base para dispositivos em rede sem
interface com o usuário.
•
PP: o Personal Profile é o perfil CDC utilizado em dispositivos que necessitam
de um suporte completo para interface com o usuário. O PP substitui a antiga
tecnologia Personal Java, que é uma versão reduzida da J2SE, destinada a
rodar em dispositivos de pouca memória e baixo poder de processamento.
•
PBP: o Personal Basis Profile é uma divisão do PP que fornece um ambiente
para dispositivos conectados, que suportem um nível básico de apresentação
gráfica.
•
MIDP: o Mobile Information Device Profile ou Perfil de Dispositivo de
Informação Móvel é um perfil direcionado para dispositivos móveis ligado ao
CLDC, fornecendo um ambiente completo para o desenvolvimento de
aplicações para dispositivos móveis. Ele define funcionalidades como interface
do usuário, suporte à rede, métodos de entrada dados, manipulação da tela do
dispositivo (display), armazenamento persistente, entre outros. Ao MIDP
podem ser adicionadas outras APIs, fornecendo novos recursos, tais como
controle de alerta vibratório, som, entre outras funcionalidades (SUN, 2004c).
As aplicações que executam em dispositivos que suportam MIDP são
denominadas MIDlets, que são pequenas aplicações escritas em Java, que rodam
em dispositivos móveis (celular, PDA, Pager, etc) e consistem em um conjunto de
APIs definidas pelo MIDP e CLDC. Uma aplicação MIDP contém no mínimo uma
classe MIDlet, o que não impede que se possa ter mais de uma MIDlet, sendo
que, neste caso, a aplicação passa a ser chamada de MIDlet Suíte (SUN, 2005b).
A Sun oferece, para o desenvolvimento de aplicações MIDlets, um kit de
ferramentas de desenvolvimento, o Java Development Kit (JDK) e um conjunto de
emuladores que permitem testar a aplicação sem a necessidade de um aparelho.
24
2.4.3 Configuração
“Uma configuração define uma plataforma mínima para um grupo de dispositivos
com
características
similares,
tanto
na
memória
como
no
poder
de
processamento” (FONSECA, 2002). Sendo assim, as configurações definem um
conjunto mínimo de biblioteca e recursos da JVM, fornecendo funcionalidades
básicas para dispositivos que possuem características limitadas, como:
conectividade, processamento e memória. Os dois tipos de configurações, CDC e
CDLC, se diferem na JVM pela capacidade de armazenamento, pelo poder de
processamento, entre outros recursos. Neste trabalho, será detalhado a
configuração CLDC, criando uma aplicação, como exemplo, na seção 2.5.
A CDC é destinada a dispositivos mais potentes, com maior capacidade de
processamento, como: sistema de navegação de carros, TV com suporte a
internet, etc. Utiliza uma máquina virtual, a Compact Virtual Machine (CVM), com
suporte a quase todas as funcionalidades presentes na versão J2SE. Inclui,
ainda, um conjunto de APIs do J2SE, que são necessárias para o
desenvolvimento destes dispositivos. As APIs que compõem a configuração CDC
são (SUN, 2004b):
•
java.math – classes que define métodos para cálculos matemáticos;
•
java.net – classes para execução de aplicações em rede;
•
java.security – classes de segurança;
•
java.text – classes para textos, números, datas etc.
•
java.lang – classes fundamentais da linguagem de programação Java;
•
java.io – entrada/saída através de streams (conjuntos) de dados;
•
java.util – variadas classes utilitárias.
E as características dos dispositivos que suportam a configuração CDC,
são as seguintes:
•
processador de 32 bits;
25
•
disponibilidade para o ambiente Java de pelo menos 512 KB de memória;
•
mais de 2 MB de memória total para armazenamento da máquina virtual
(CVM) e bibliotecas de classe;
•
conectividade a algum tipo de rede, frequentemente sem fios e de alta
velocidade;
•
interface com alguma sofisticação.
Já a CLDC define um ambiente de execução com um conjunto de APIs
para dispositivos com menor poder de processamento, baixos recursos de
memórias e conectividade (SCHMITT, 2004), como: celulares, SmartPhones,
pagers e PDAs. Usa uma máquina virtual reduzida, a KVM (Kilo Virtual Machine),
em relação à máquina virtual clássica, a JVM (descritas nas próximas seções).
As APIs da CLDC podem ser divididas em duas categorias: A primeira são
subconjuntos da J2SE. Porém, essas APIs não possuem todos os elementos
contidos no J2SE (SUN, 2004b):
•
java.lang;
•
java.io;
•
java.util.
A segunda é específica da CLDC, mas que podem ser mapeadas para
J2SE (SUN, 2004b):
•
javax.microedition.io - classes para conexões;
•
javax.microedition.media - classes multimídia;
•
javax.microedition.rms - classes de armazenamento;
•
javax.microedition.lcdui - classes de interface gráfica;
•
javax.microedition.midlet - classes para aplicação midlet;
•
javax.microedition.pki - classes de segurança.
Os elementos que compõe as APIs da configuração CLDC, foram divididos
nas Figuras 3, 4 e 5.
26
Figura 3 – Elementos das APIs da configuração CLDC
A Figura 3 ilustra as APIs java.lang, java.io e java.util, existentes na
configuração CLDC.
27
Figura 4 – Elementos das APIs da configuração CLDC
A Figura 4 ilustra as APIs microedition.pki, microedition.midlet e
microedition.media, existentes na configuração CLDC.
Figura 5 – Elementos das APIs da configuração CLDC
28
A
Figura
5
ilustra
as
APIs
microedition.io,
microedition.rms
e
microedition.lcdui, existentes na configuração CLDC
Como características principais, os dispositivos que suportam a CLDC
devem ter:
•
no mínimo 192 kb de memória total disponível para a plataforma Java;
•
um processador de 16 ou 32 bits;
•
baixo consumo de energia, freqüentemente usando energia de baterias;
•
conectividade a algum tipo de rede por meio de tecnologia sem fio, conexão
intermitente e com banda limitada.
O fato das bibliotecas de classes contidas na CLDC serem mais limitadas e
possuírem máquina virtual reduzida faz com que algumas funções usadas no
J2SE sejam eliminadas. Isto porque, por exemplo, muitos dispositivos não
suportariam operações com ponto flutuante e recursos de interface nativa (JNI),
devido ao custo da implementação do ponto flutuante ser considerado alto. Já o
JNI foi eliminado por razões de limitações de memória (SUN, 2004b).
2.4.4 APIs opcionais
A J2ME pode ser ampliada pela combinação de vários pacotes de APIs opcionais.
São bibliotecas de programação específicas a uma determinada tecnologia e que
aumentam as capacidades do ambiente Java, caso estejam implementadas no
dispositivo (SUN, 2004b). Criada para atingir requisitos específicos de mercado,
as APIs mais conhecidas são a WMA (Wireless Messaging API), que permite às
aplicações J2ME manipularem mensagens SMS (Short Message Service) e
MMAPI (Mobile Media API) que adiciona controle de mídia, fornecendo recursos
de reprodução, captura e edição de vídeos e áudios às aplicações J2ME (SUN,
2004b). Estes pacotes são chamados opcionais porque, mesmo que não estejam
implementados em uma aplicação, o mesmo continua a ser uma aplicação J2ME.
29
2.4.5 Máquina virtual
A J2ME dispõe de duas máquinas virtuais distintas que podem ser utilizadas no
desenvolvimento de aplicações para dispositivos móveis, a CVM (Compact Virtual
Machine) e a KVM (Kilo Virtual Machine). Conforme Fonseca (2002), a máquina
virtual do J2ME, chamada de KVM, não é a mesma utilizada pelas versões J2EE
e J2SE, sendo quase sempre um conjunto reduzido dessas versões. Já a
máquina virtual CVM atende a especificação completa da JVM, porém apresenta
menos requisitos de memória.
A CVM é a máquina virtual compactada da versão padrão do Java,
específica para configurações CDC, suporte a dispositivos móveis com, no
mínimo, 32 bits e mais de 2 MB de memória. O perfil Personal Profile é o mais
encontrado, destinada, por exemplo, a TVs.
Segundo Fonseca (2002), a KVM é uma máquina virtual voltada para
dispositivos portáteis e com pouco poder de processamento, como PDAs,
celulares e SmartPhones. A KVM surgiu como uma máquina virtual de referência
para
a
configuração
CLDC,
cumprindo
todas
as
especificações
desta
configuração. A KVM recebe esse nome porque o gasto de memória é medido em
kilobytes, ao contrário dos sistemas tradicionais, que a medida padrão utilizada é
o megabyte. Foi implementada para ser usada em dispositivos de recursos
limitados, porém, trabalha com o mesmo conjunto de bytecodes e a mesma
extensão ‘.class’ que a JVM (SUN, 2005a).
2.5 Web Services
Web Services são tecnologias utilizadas para integrar sistemas por meio da
Internet, independentes plataforma ou linguagem de programação (NETO, 2003).
Isto é, são aplicações definidas e descritas usando a XML (Extensive Markup
Language). XML é uma linguagem de marcação projetada para a criação de
documentos Web, contribuindo para a interoperabilidade entre os diferentes
dados na Web (XML, 2003), ou seja, é uma linguagem que representa os serviços
do Web Service, que pode ser acessado por diversos clientes (aplicações).
30
O Web Service não precisa estar necessariamente disponível no ambiente
Web, pois o mesmo pode ser utilizado em qualquer rede de trabalho, como a
intranet (GUMZ, 2005). Geralmente, é utilizado o protocolo Hypertext Transfer
Protocol (HTTP) para efetuar a comunicação entre o cliente e o Web Service,
mesmo estando em ambientes e sistemas diferentes.
Para efetuar a comunicação entre o cliente e o Web Service é utilizado um
protocolo, o SOAP (Simple Object Acess Protocol). O SOAP é um protocolo para
troca de informações entre sistemas Web, projetado para ser usado no acesso a
objetos remotos, através da troca de mensagens XML, que contém informações a
serem transmitidas de um sistema para outro (SOAP, 2003).
Para que os serviços do Web Service sejam acessados é oferecido um
serviço chamado Web Service Description Language (WSDL), que consiste,
basicamente, de uma linguagem baseada em XML (WSDL, 2003), criada para
descrever os serviços do Web Service. Para definir uma maneira padrão de
publicar informações e anunciar os serviços de um Web Service, foi criado o
UDDI
(Universal
Description,
Discovery,
and
Integration),
que
funciona
basicamente como um diretório de Web Service, ou seja, trata-se de um cadastro
global de Web Services (UDDI, 2003).
Para a criação de Web Services, existem plataformas como: .NET e Java,
que oferecem recursos necessários para o seu desenvolvimento, apresentados
nas próximas seções.
2.5.1 A utilização de Web Services pela plataforma Java
Para a utilização de Web Services em aplicações desenvolvidas segundo a
arquitetura Java, a Sun criou um conjunto de APIs Java para o desenvolvimento
de Web Services e aplicações Web, chamado de JWSDP (Java Web Service
Develoment Pack), que oferece um conjunto de soluções para construir, testar e
publicar aplicações utilizando os conceitos do XML (SUN, 2003). A seguir, serão
citados alguns exemplos de APIs Java para Web Service (SUN, 2003):
•
Java API for WML Processing (JAXP): é um conjunto de APIs que permite
processar documentos XML;
31
•
SOAP with Attachments API for Java (SAAJ): é um conjunto de APIs que
suporta o envio de documentos usando SOAP;
•
Java API for WML Registries (JAXR): é um conjunto de APIs que permite
aderir a serviços de registros baseado em XML, como o UDDI;
•
Java API for XML Remote Procedure Call (JAX-RPC): é um conjunto de APIs
que suporta a comunicação do tipo RPC sobre SOAP e define regras para
construção de aplicações Web Service.
A JAX-RPC é a principal API para a criação de Web Service. Ela permite a
construção do processo de comunicação entre cliente e servidor de Web Service.
A comunicação do tipo RPC, ou chamadas remotas de procedimento, são
chamadas locais a métodos de objetos ou serviços remotos, ou seja, podem-se
acessar os serviços de um objeto localizado em um outro ponto da rede através
de uma chamada local a este objeto, usando a plataforma Java (SUN, 2003).
Para a integração de aplicações J2ME com Web Services são necessários
dois pacotes: o KSOAP e KXML. Estes pacotes permitem que as aplicações para
dispositivos móveis funcionem na máquina virtual KVM (MCHUGH, 2003).
O
KSOAP é responsável por oferecer suporte ao protocolo SOAP e o KXML é
responsável por dar suporte à linguagem XML.
Os Web Services viabilizam a integração entre plataformas diferentes,
garantindo a interoperabilidade, ou seja, os serviços desenvolvidos na plataforma
Java poderão ser acessados por aplicações .NET e vice-versa.
2.5.2 A utilização de Web Services pela plataforma .NET
A .NET oferece uma independência de linguagem no desenvolvimento de Web
Services (MSDN, 2003). É um ambiente que proporciona integração entre as
diversas aplicações existentes, realizando a troca de informações entre elas e
otimizando os recursos de comunicação da internet. Essa comunicação é feita por
meio da leitura de documentos WSDL, que é um documento em XML que contém
as funcionalidades do Web Service.
32
No ambiente .NET, as funcionalidades dos Web Services podem ser
definidas em arquivos do tipo ‘.asmx’. O código desse arquivo utiliza o atributo
<WebMethod()>, responsável por definir os métodos do Web Service, que
ficarão disponíveis
aos clientes (aplicações). Para que as funcionalidades do
Web Service estejam disponíveis para outras aplicações, é necessário que o
arquivo ‘.asmx’ esteja em uma pasta virtual de um servidor Web que possua o IIS
(Internet Information Services) e a plataforma .NET instalados (SANTOS, 2003).
A plataforma .NET disponibiliza uma ferramenta que oferece um
desenvolvimento unificado do Web Service e da aplicação que irá utilizá-lo, o
Visual Studio.NET. Para a realização de testes dos Web Services, o acesso pode
ser realizado através do browser, que permite a visualização das suas
funcionalidades.
O XML é uma linguagem que descreve as funcionalidades do Web Service,
permitindo que aplicações possam trocar informações com plataformas diferentes,
como a Java e .NET. A Figura 6 mostra as camadas de desenvolvimento de
aplicações .NET e Java que possui a camada de comunicação dos Web Services.
Figura 6 – Camadas de desenvolvimento de aplicações .NET e Java (OLIVEIRA,
2004)
A Figura 6 mostra as camadas de desenvolvimento de uma aplicação na
plataforma .NET e Java, e é na camada de rede, via HTTP, que os Web Services
se comunicam, isto é, uma aplicação feita em uma linguagem, precisa apenas
33
reconhecer um arquivo XML para se conectar a um Web Service feito em outra
linguagem (OLIVEIRA, 2004).
A seguir será apresentada uma aplicação que servirá para exemplificar
algumas das características apresentadas anteriormente. Para o desenvolvimento
da aplicação foi utilizado a ferramenta NetBeans 5.0, utilizando a plataforma
J2ME. O Web Service foi desenvolvido na plataforma .NET, o mesmo que foi
utilizado em (SILVA, 2006). Para a visualização e realização dos testes foi
utilizado um emulador, o NetBeans Mobility 5.0.
2.5 Exemplificação da Integração das Tecnologias
Para ilustrar as funcionalidades oferecidas pela plataforma J2ME, foi desenvolvida
uma aplicação J2ME CLDC/MIPD que poderá enviar ou buscar informações
utilizando os serviços de um Web Service, o qual é o responsável por realizar a
conexão entre o banco de dados e a aplicação, promovendo uma distribuição do
processamento. Esta aplicação visa oferecer uma forma alternativa para que os
alunos que tenham participado do vestibular do CEULP-ULBRA possam acessar
o resultado através de um dispositivo móvel. O esquema navegacional utilizado
nesta aplicação pode ser visualizado na Figura 7.
Figura 7 – Esquema navegacional
A aplicação desenvolvida consiste em cinco formulários: o primeiro é o
formulário inicial, ou seja, é a página principal que é responsável pela escolha da
consulta. O formulário de consulta por nome é o responsável por receber os
34
valores da consulta; outro formulário consiste em apresentar o resultado da
consulta, sendo responsável por exibir os nomes dos candidatos aprovados e/ou
suplentes; o formulário de consulta por número recebe os valores que servirão
como parâmetros para a consulta; e, por fim, o formulário que exibe os resultados:
a colocação do candidato, sua nota e sua situação (aprovado, reprovado ou
suplente).
O frmInicial dispõe de um menu com as opções de consultas que o
usuário deseja realizar e outro que encerra a execução, conforme ilustrado na
Figura 8.
Figura 8 - Tela da página inicial da aplicação
O frmInicial é composto por dois tipos de consultas (Nome ou
Número) e, após a escolha de uma das opções pelo usuário, outro formulário é
apresentado, que servirá para a inserção dos valores para a consulta. A outra
opção do menu refere-se a opção “Sair”, que tem a função de encerrar a
35
execução. Assim, o código desse formulário é formado basicamente pela
implementação das funções do menu, conforme mostra a Figura 9.
1. public
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
15.
}
void commandAction(Command c, Displayable d) {
if (c == btnSair) {
notifyDestroyed();
}
else if (c == consultarNumero) {
Display.getDisplay(this).setCurrent(frmNumero);
}
else if (c == consultarNome) {
Display.getDisplay(this).setCurrent(frmNome);
}
else if (c == voltar) {
Display.getDisplay(this).setCurrent(frmInicial);
}
Figura 9 – Código de implementação das funções do menu
Após a definição da consulta, outro formulário é chamado. Por exemplo, se
a consulta for por número, o formulário chamado será frmNumero, conforme
mostra entre as linhas 5 e 7 da Figura 9. No frmNumero é inserido o número de
inscrição do aluno para que seja realizado a consulta, após a seleção da opção
consultar, o resultado é apresentado em outro formulário, o frmResultadoNum,
conforme mostra a seqüência da Figura 10.
36
Figura 10 – Seqüência da consulta por número
O
resultado
da
consulta
vêm
do
método
do
Web
Service
consultarPorNumero. O Web Service, criado na plataforma .NET, é
composto
por
dois
tipos
de
consulta:
consultarPorNome, como mostra a Figura 11.
consultarPorNumero
e
37
Figura 11 – Métodos do Web Service
Na Figura 8, nota-se os métodos de consulta que foram criados, chamados
consultarPorNome e consultarPorNumero. É possível acessá-los
clicando sobre o link do método. Após isso, uma nova janela é aberta onde irá
requerer os valores passados como parâmetro para a execução do método. A
Figura 12 demonstra a janela para inserção do valor para execução do método
consultarPorNumero.
38
Figura 12 – Janela para inserção do método consultarPorNumero
Após a inserção do valor, pode-se invocar o método clicando no botão
Invoke. O método é responsável por apresentar a nota, situacao e
posicao do usuário que solicitou a consulta. O resultado da execução do
método é retornado em XML, conforme apresentado na Figura 13.
39
Figura 13 – Resultado da execução do método consultarPorNumero
Na
aplicação,
esse
resultado
é
apresentado
no
formulário
frmResultadoNum. Ou seja, após a inserção dos valores no formulário de
consulta por número e de selecionar a opção “consultar” do menu, o método
correspondente do Web Service é invocado e o resultado é retornado para o
formulário frmResultadoNum, e é apresentado na tela do emulador, conforme
foi mostrado na Figura 10. A integração da aplicação com o Web Service é
apresentada no código da Figura 14, que representa a classe de conexão da
aplicação com o Web Service.
40
1. import org.ksoap.SoapObject;
2. import org.ksoap.transport.HttpTransport;
3. import org.kxml.parser.*;
4.
5. public class ConexaoWS {
6. private String url = "http://localhost/WSSeguro/Service.asmx";
7.
public ConexaoWS(String url) {
8.
this.url = url;
9.
}
10. public String consultarPorNome(String nomeCandidato) {
11.
StringBuffer resultado = new StringBuffer();
12.
SoapObject obj = new SoapObject(url, "consultarPorNome");
13.
obj.addProperty("nomeCandidato", new String(nomeCandidato));
14.
HttpTransport http = new HttpTransport(url, "consultarPorNome");
15.
try {
16.
resultado.append(http.call(obj));
17.
} catch(Exception ex) {
18.
System.out.println(ex.getMessage());
19.
}
20.
return resultado.toString();
21. }
22.
23. public String consultarPorNumero(String idCandidato) {
24.
StringBuffer resultado = new StringBuffer();
25.
SoapObject obj = new SoapObject(url, "consultarPorNumero");
26.
obj.addProperty("idCandidato", new String(idCandidato));
27.
HttpTransport http = new HttpTransport(url, "consultarPorNumero");
28.
try {
29.
resultado.append(http.call(obj));
30.
} catch(Exception ex) {
31.
System.out.println(ex.getMessage());
32.
}
33.
return resultado.toString();
34. }
35. }
Figura 14 – Código da classe de conexão com o Web Service
Entre as linhas 1 e 3 está representado os pacotes KSOAP e KXML,
necessários para a integração da aplicação com o Web Service. As linhas 5 e 9
mostra criação do objeto que irá receber o caminho da conexão com o Web
Service. Entre as linhas 10 e 21 mostra a conexão da aplicação com o método
consultarPorNome do Web Service. E entre as linhas 23 e 34 mostra a
conexão da aplicação com o método consultarPorNumero do Web Service.
A Figura 15 detalha a implementação do método de consulta por número da
aplicação.
41
1. public String consultarPorNumero (String idCandidato) {
2.
StringBuffer resultado = new StringBuffer();
3.
SoapObject obj = new SoapObject(url, "consultarPorNumero");
4.
obj.addProperty("idCandidato", new String(idCandidato));
5.
HttpTransport http = new HttpTransport(url, "consultarPorNumero");
6.
try {
7.
resultado.append(http.call(obj));
8.
} catch(Exception ex) {
9.
System.out.println(ex.getMessage());
10.
}
11.
return resultado.toString();
12. }
Figura 15 - Código do método de consulta por número
A linha 2 mostra a criação da variável que irá receber o resultado da
consulta. Na linha 3, cria-se um objeto do tipo SoapObject permitindo que a
aplicação localize o Web Service por meio do objeto criado na classe de conexão,
chamado “url”, e o método correspondente à consulta. Na linha 4, estão os
parâmetros para o método do Web Service. Na linha 5, estão os códigos de
transporte do resultado para a aplicação. E a linha 11, retorna o resultado
correspondente à consulta.
Esta aplicação foi desenvolvida, por meio do embasamento teórico
adquirido, e que auxiliará na criação de um comparativo entre as plataformas
.NET Compact Framework e J2ME no desenvolvimento de aplicações para
dispositivos móveis, que será apresentado no capítulo 4 deste trabalho.
42
3.
MATERIAIS E MÉTODOS
Neste capítulo serão apresentados os recursos utilizados para realização e
conclusão deste trabalho, como, por exemplo, estudos bibliográficos e recursos
de hardware e software.
3.1 Local e Período
O trabalho foi desenvolvido como requisito da disciplina de Trabalho de
Conclusão de Curso em Sistemas de Informação I e II, do curso de Sistemas de
Informação do Centro Universitário Luterano de Palmas, no primeiro semestre de
2006 e foi desenvolvido no laboratório do Programa Gerador de Novos
Referenciais Tecnológicos para a Região Norte - GENORTE. As atividades
relacionadas a este trabalho tiveram início no mês de janeiro de 2006 e término
em julho de 2006.
3.2
Materiais
Os materiais utilizados para a realização deste trabalho, podem ser divididos em
três categorias: hardware, software e fontes bibliográficas.
3.2.1 Hardware
•
Notebook com processador Intel inside Celeron M, com clock de 1.4 Ghz,
512 Mb de memória RAM e HD com 60 Gb.
43
3.2.2 Software
•
Microsoft Wod 2003;
•
Microsoft SQL Server;
•
Microsoft Visual Studio 2005 Beta 2;
•
Adobe Acrobat Reader;
•
NetBeans 5.0;
•
NetBeans Mobility 5.0.
3.2.3 Fontes Bibliográficas
•
Trabalhos de Conclusão de Curso;
•
Dissertações de Mestrado;
•
Publicações Científicas;
•
Artigos;
•
Livros;
•
Sites diversos.
3.3 Metodologia
A metodologia utilizada iniciou-se com estudos teóricos sobre programação para
dispositivos móveis, plataforma .NET Compact Framework, plataforma J2ME e o
consumo de Web Service. Estes estudos foram aplicados para a finalização
desse trabalho.
Este trabalho teve como finalidade o desenvolvimento de uma aplicação
para dispositivos móveis utilizando a plataforma J2ME, para verificar o resultado
do vestibular do CEULP/ULBRA, estes dados estão armazenados em um banco
de dados e a utilização de um Web Service, desenvolvido na plataforma .NET,
que buscará os dados e os retornará para a aplicação. Tendo como objetivo,
realizar um comparativo entre as plataformas .NET Compact Framework e J2ME,
no desenvolvimento de aplicações para dispositivos móveis.
44
4.
RESULTADOS E DISCUSSÕES
O objetivo deste capítulo é apresentar um comparativo entre as plataformas .NET
Compact Framework e J2ME, usando a configuração CLDC, no desenvolvimento
de aplicações para dispositivos móveis. A plataforma J2ME e seus componentes
surgiram primeiro, e por mais de cinco anos era a única plataforma viável para o
desenvolvimento de aplicações para dispositivos móveis (YUAN, 2003). A
Microsoft, acompanhando o crescente mercado, de dispositivos móveis visualizou
e criou uma plataforma de desenvolvimento para dispositivos móveis, a .NET
Compact Framework (.NET CF).
O comparativo irá abordar estudos de desenvolvimentos de aplicativos
para dispositivos móveis nas plataformas .NET CF e J2ME, das arquiteturas,
recursos de desenvolvimento, linguagens, classes, componentes, serviços,
suporte a Web Services, entre outras informações.
4.1 Arquitetura das plataformas .NET CF e J2ME
As
plataformas
.NET
CF
e
J2ME
caracterizam
idéias
inovadoras
no
desenvolvimento de aplicações para dispositivos móveis. A plataforma Java
representa mais do que apenas uma linguagem de programação, abrangendo
tecnologia como: máquinas virtuais que funcionam em várias arquiteturas e a
J2ME
no
desenvolvimento
de
aplicativos
móveis.
A
plataforma
.NET,
predominante no desenvolvimento de aplicações desktop, dispõe de uma
tecnologia de desenvolvimento de aplicações para dispositivos móveis, a .NET
CF.
A arquitetura da plataforma J2ME é dividida em: perfil, configuração e
máquina virtual. Para realizar o estudo comparativo, foram abordadas somente as
45
características da configuração CLDC, pois foi a utilizada no desenvolvimento da
aplicação que serviu como exemplo neste trabalho. A arquitetura é apresentada
na Figura 16.
Figura 16 - Arquitetura J2ME usando a CLDC
A arquitetura apresentada na Figura 15 representa as camadas de
desenvolvimento de uma aplicação J2ME que utiliza a configuração CLDC,
destinada a dispositivos como menor poder de processamento, com perfil MIPD
baseada na CLDC e a máquina virtual KVM. Os pacotes opcionais oferecem APIs
para tecnologias como Bluetooth, Web Services, conexão com banco de dados e
envio de mensagens, estendendo as funcionalidades básicas oferecidas pelas
MIPD e a CLDC.
A arquitetura da plataforma .NET CF não define configurações, ao contrário
do J2ME. Consiste em biblioteca de classes e Common Language Runtime
(CLR), conforme apresentado na Figura 17.
Figura 17 – Arquitetura da .NET Compact Framework
A biblioteca de classes da plataforma .NET Compact Framework é
composta de classes, relações e tipos incluídos na estrutura Microsoft .NET. Esta
biblioteca fornece o acesso à funcionalidade dos sistemas, aplicações,
componentes e controles. A CLR pode ser analisada como uma máquina virtual,
46
mas com um poder de processamento maior. A CLR permite o desenvolvimento
em qualquer ambiente, e é na camada CLR que a aplicação é executada, oferece
também serviços como gerência de memória e manipulação de exceção.
4.2 Biblioteca de classe das plataformas .NET CF e J2ME
A biblioteca de classes define as funcionalidades das aplicações, dando suporte
ao desenvolvimento. As classes disponíveis para o J2ME são definidas no perfil e
em pacotes opcionais. Para o desenvolvimento das aplicações, as classes
responsáveis pela interface com o usuário, tanto na .NET Compact Framewok,
como no J2ME, são compostas de um conjunto variado de controles, como
mostra a Tabela 1.
Tabela 1 – Classes de Interface (MSDN, 2003 e SUN, 2004b)
.NET Compact Framework
System.Windows.Forms
Microedition.Lcdui
CheckBox
ComboBox
ContextMenu
Control
Cursor
Classes de Interface
J2ME
DataGrid
DomainUpDown
Label
Form
HScrollBar
ImageList
InputPanel
ListBox
ListView
MainMenu
MessageWindow
NumericUpDown
OpenFileDialog
Painel
PictureBox
ProgressBar
RadioButton
Alert
AlertType
Canvas
Choice
ChoiceGroup
Command
CommandListener
DateField
Display
DisplayTable
Font
Form
Gauge
Graphics
Image
ImageItem
Item
ItemStateListener
List
Screen
StringItem
TextBox
47
SaveFileDialog
StatusBar
TabControl
TabPage
Timer
TextBox
ToolBar
TrackBar
TreeView
VScrollBar
TextField
Ticker
As classes de interface com o usuário contidas nas plataformas .NET CF e
J2ME são compostas por controles. A .NET CF engloba uma variedade maior de
dispositivos móveis, com isso, dispõe de um número maior de controles em
relação a plataforma J2ME, conforme especificado na Tabela 4. Os controles
apresentados da J2ME tratam-se da configuração CLDC, que engloba
dispositivos com menor poder de processamento, como: celulares, SmartPhones,
pagers e PDA´s.
Porém, os controles dispostos na classe de interface da .NET CF são
definidos de acordo com as características da aplicação a ser desenvolvida, ou
seja, nem todos os controles dispostos nas classes de interface estão disponíveis
para qualquer tipo de aplicação, pois é necessário avaliar o tipo de aplicação e os
recursos oferecidos. Na J2ME, por dividir as configurações em CDC e CLDC, as
classes são definidas de acordo com a escolha da configuração.
Muitos dos controles são similares nas duas plataformas, como o
TextBox, disponível na .NET CF e TextField da J2ME, ambos responsáveis
por aceitar a entrada de texto na aplicação. A Figura 18 mostra o código da
declaração dos controles na plataforma .NET CF.
1. private TextBox txtNome;
...
5. this.txtNome=new System.Windows.Forms.TextBox();
Figura 18 – Código do controle TextBox
48
A linha 1 apresenta a declaração do controle TextBox e a linha 5 a
criação do comando do controle, criados na linguagem C#. A Figura 19 mostra o
código da declaração dos controles na plataforma J2ME.
1. private TextField txtNome;
...
5. this.txtNome=new TextField("","", 20, TextField.ANY);
Figura 19 – Código do controle TextField
A linha 1 apresenta a declaração do controle TextField e a linha 5 a
criação do comando do controle, criados na linguagem Java.
Na plataforma J2ME é possível adicionar pacotes opcionais, que são
classes que estendem as funcionalidades da aplicação, como os pacotes de Web
Services compostos pelos KSOAP e KXML, que dão suporte ao protocolo SOAP
e a linguagem XML. O código de utilização desses pacotes opcionais declarados
na aplicação J2ME é mostrado na Figura 20.
1.
import org.ksoap.SoapObject;
2. import org.kxml.transport.HttpTransport;
Figura 20 – Código dos KSOAP e KXML
As linhas 1 e 2 declaram os códigos que dão suporte a aplicações J2ME
que utilizam serviços de Web Service, implementado na linguagem Java.
A plataforma .NET CF contém a classe que dá suporte a serviços de Web
Service, chamada de System.Web.Services, que consiste em classes que
permitem a criação de serviços usando a linguagem XML. Os serviços Web
Service usando XML são as aplicações que usam protocolos tais como: HTTP,
XML, SOAP e WSDL. Estes serviços garantem interoperabilidade com uma
variedade de plataformas, aplicações e dispositivos. O código das classes Web
Service utilizados nas aplicações .NET CF é mostrado na Figura 21.
49
1.
using System.Web.Services;
Figura 21 – Código da classe Web Service
A linha 1 especifica o código da classe Web Service que é inserido na
aplicação .NET CF, que dá suporte as funcionalidades do Web Service,
implementado na linguagem C#.
As plataformas .NET CF e J2ME dispõe de classes com funcionalidades
semelhantes como mostra a Tabela 2.
Tabela 2 – Classes de Entrada e Saída (MSDN, 2003 e SUN, 2004b)
Classes de Entrada e Saída
.NET Compact Framework
System.IO
J2ME
Java.IO
Directory
File
FileStream
Stream
StreamReader
StreamWriter
TextReader
TextWriter
ByteArray
DataInput
DataOutput
InputStream
OutputStream
PrintStream
Reader
Write
Como parte da biblioteca de classes das plataformas .NET CF e J2ME, as
classes System.IO e Java.IO são responsáveis pelo manuseio de arquivos,
permitindo a leitura e a escrita em arquivos de dados. As classes TextWriter e
Write, são classes abstratas e representam um escritor de caracteres
seqüências.
Mesmo sendo um subconjunto da plataforma .NET, a .NET CF fornece
estrutura necessária para a criação de aplicações para dispositivos móveis, como
as classes apresentadas, oferecendo suporte também, a classes como:
•
System.Security – classes que fornecem estruturas de segurança;
•
System.Net – classes de aplicações em rede;
•
System.Text – classes para caracteres, textos, números etc;
•
System.Web – classes de manipulação, transferência de arquivos etc.
50
A plataforma J2ME fornece a estrutura necessária para a criação de
aplicações para dispositivos móveis, com classes que oferecem suporte ao
desenvolvimento. É possível dizer que as plataformas .NET CF e J2ME possuem
classes semelhantes no desenvolvimento de aplicações, sendo necessário avaliar
o tipo da aplicação a ser desenvolvida, os recursos disponíveis, avaliar custos e
benefícios, a fim de tomar decisões como, a escolha da plataforma, as
ferramentas de desenvolvimento, linguagens, entre outros componentes mais
adequados às suas necessidades.
4.3 Processo de desenvolvimento de aplicações nas plataformas .NET CF e
J2ME
As plataformas .NET CF e J2ME possuem recursos de configuração,
implementação, bibliotecas de classes, ou seja, recursos para o desenvolvimento
de aplicações para dispositivos móveis, tanto comercial, quanto de uso pessoal.
Estas plataformas, no processo de desenvolvimento de aplicações para
dispositivos móveis, incluem recursos como: ferramentas de desenvolvimento,
linguagens, ambiente de execução dos programas e o emulador, que permite
testar as aplicações.
4.3.1 Ferramentas de desenvolvimento
As ferramentas de desenvolvimento visam melhorar a produtividade do
programador ao construir aplicações. O desenvolvimento de uma aplicação pode
ser realizado em um simples editor de texto ou em ferramentas mais sofisticadas,
e a escolha depende da aplicação a ser desenvolvida.
As aplicações para dispositivos móveis, desenvolvidas na plataforma
J2ME, utilizam o Java como linguagem de programação. Mas, nem por isso os
aplicativos desenvolvidos em J2ME se limitam aos recursos oferecidos pelo Java,
já que esta plataforma possui suporte ao uso da tecnologia de Web Services, que
acrescenta funcionalidades a aplicação. Para o desenvolvimento destas
aplicações existe uma larga escala de ferramentas livres, sendo que as mais
comuns são:
51
•
JUnit;
•
Ant;
•
Eclipse;
•
NetBeans;
•
Java 2 Micro Edition Wireless Toolkit.
A plataforma .NET CF possibilita o desenvolvimento de aplicações para
dispositivos móveis utilizando linguagens como VB.NET, C# ou J#, ou o
desenvolvimento em multilinguagens, desde que sejam compatíveis com a .NET.
A ferramenta de desenvolvimento de aplicações .NET CF mais comum é a Visual
Studio.NET.
Esta
ferramenta
oferece
um
ambiente
que
permite
o
desenvolvimento de aplicações em uma mesma ferramenta, sem a preocupação
com o formato do aparelho a ser utilizado, bem como quais os recursos que o
mesmo disponibilizará. Além de possibilitar a criação e a utilização de Web
Services pelas aplicações .NET CF.
4.3.2 Ambiente de execução
O ciclo de execução de uma aplicação .NET CF acontece na CLR (Common
Language Runtime), junto com a biblioteca de classes que formam um ambiente
de execução que oferece um gerenciamento de código (Managed Code)
(JUNIOR, 2006). Um código gerenciado garante, em tempo de execução, a
eliminação dos erros na aplicação, além do monitoramento realizado pelo coletor
de lixo (Garbage Collector). Outro item importante é o compilador Just-In-Time
(JIT), outro componente da CLR, responsável por gerar o chamado código
Microsoft Intermediate Language (MSIL), abreviado como Intermediate Language
(IL) (JUNIOR, 2006). O ciclo de execução de uma aplicação .NET CF é mostrado
na Figura 22.
52
CLR
Aplicativo
inicial
(Class Loader)
IL
Coletor de Lixo
(Garbage Collector)
JIT
Aplicativo
final
Emulador
Figura 22 - Ciclo de execução da aplicação .NET CF
Quando a aplicação é iniciada, já é alocado um espaço de memória para
sua execução, conhecido como domínio da aplicação (Application Domains),
assegurando que não irão existir conflitos entre outras aplicações que
possivelmente estão sendo executadas. Após isso, vem o carregador de classes
(Class Loader), que tem a responsabilidade de carregar os arquivos necessários
para a execução da aplicação. Nestes arquivos incluem-se a biblioteca de classe
usada na aplicação, além dos recursos, por exemplo, de imagens.
Em seguida é usado o coletor de lixo, que envolve a busca, avaliação e
eliminação dos espaços de memória e alguns erros de programação comuns. O
arquivo é compilado pelo JIT, que gera um código denominado IL, este é o código
que será executado pela CLR. Ou seja, as linguagens contidas no arquivo são
compiladas para um código intermediário (IL) que define as instruções para o
CLR, depois disso, o código IL será compilado para código de máquina, criando,
assim, um aplicativo único.
Após a execução e eliminação dos erros, a aplicação é testada em um
emulador. A execução de uma aplicação J2ME é feita em uma máquina virtual. A
execução é dividida em duas versões, baseadas em um conjunto de configuração
e perfil, que definem a máquina virtual. Este conjunto é composto pela
configuração CDC, seus perfis e a máquina virtual CVM (Compact Virtual
53
Machine) e a configuração CLDC com o perfil MIDP e que utiliza a máquina virtual
KVM (Kilo Virtual Machine).
De modo geral, uma aplicação J2ME é desenvolvida, compilada, préverificada, empacotada e descrita. O ciclo de execução de uma aplicação J2ME
usando MIDP/CLDC e a KVM é apresentada na Figura 23.
.class
Pacote JAR e JAD
MIDP
CLDC
KVM
.java
Emulador
Debbuger
Pré-verificação
Figura 23 - Ciclo de execução da aplicação J2ME
As aplicações que executam em dispositivos que suportam MIDP são
denominadas MIDlets. Ao iniciar o desenvolvimento é criada uma aplicação com a
extensão ‘.java’. Durante a execução é feita a eliminação de erros através do
debbuger. O debbuger busca remover informações irrelevantes das classes,
como nomes de variáveis.
A execução continua com a conversão do código de bytes em código
executável de máquina, isto é, após a compilação dos programas Java (‘.java’) é
gerado um arquivo de extensão chamado ‘.class’. Com o arquivo ‘.class’ gerado é
feita uma pré-verificação, que é realizada fora o sistema onde será executada a
aplicação, permitindo um verificação mais rápida da KVM. A pré-verificação dos
arquivos de classes é dividida em duas fases: uma pré-verificação no computador
de desenvolvimento da aplicação sem mudar o nome do arquivo e uma
verificação no dispositivo ou emulador no momento da execução.
Após a compilação e pré-verificação será criado um pacote que contém o
arquivo .JAR (Java Archive). Este arquivo possui um arquivo descritor, chamado
.JAD (Java Application Descriptor), em que ficam as informações referentes ao
tamanho do arquivo .JAR, versão, configuração, perfil, nome da MIDlet, entre
54
outras. Com a criação do .JAD e as especificações do .JAR, o mesmo será
executado no emulador. A KVM é responsável pelo gerenciamento das aplicações
à medida que são executadas.
As execuções das aplicações criadas nas plataformas .NET CF e J2ME,
seguem um padrão semelhante. Ambas utilizam um serviço de coleta de lixo, que
gerenciam as memórias e os códigos, garantindo que nenhuma instrução inválida
apareça no código.
Na compilação dos códigos, a plataforma J2ME transforma o código de
bytes em código de máquina, empacotado em um arquivo .JAR. Já a plataforma
.NET CF, por possuir independência de linguagem, possui um mecanismo de
compilação diferente da J2ME, em que na .NET CF, primeiro é feita a compilação
do código para uma linguagem intermediária (IL), depois esta IL é compilada,
gerando o código de máquina.
A fim de avaliar algumas características das plataformas .NET CF e J2ME
CLDC foi criada uma tabela de comparativo entre as plataformas.
Tabela 3 – Tabela de comparativo entre as plataformas .NET CF e J2ME
COMPARATIVO
.NET Compact Framework
J2ME – CLDC
Dispositivos
Dispositivos com maior e
menor
poder
de
processamento tais como:
celulares,
SmartPhones,
PDA´s e Set-Tops Boxes.
Dispositivos com menor poder de
processamento, tais como: celulares,
pagers, SmartPhones e PDA´s.
Custo
Para o desenvolvimento das
aplicações, as ferramentas e
alguns recursos necessários
precisam ser pagos, além de
alguns
dispositivos
alvos
terem um custo alto, tendo
assim, um custo elevado no
desenvolvimento
e
na
utilização da aplicação.
Existe uma variedade de ferramentas
livres para o desenvolvimento das
aplicações, porém os dispositivos
alvos possuem um custo, tendo
assim
um
custo
médio
de
desenvolvimento e utilização da
aplicação.
Corporativos
Corporativos e pessoais
Mercado
55
Possui suporte a várias
linguagens,
como:
C#,
VB.NET e J#
Suporte a linguagem Java
Pocket PC, Windows CE
Todas
as
plataformas
para
dispositivos móveis, como: Windows,
Linux e Solaris, necessitando apenas
de uma máquina virtual instalada.
Subconjunto da .NET
Compatibilidade parcial com J2SE,
junto com pacotes opcionais.
A
Ferramenta
Visual
Studio.NET é a mais comum
no
desenvolvimento
das
aplicações.
Existe um número grande de
ferramentas para o desenvolvimento
das aplicações, tais como: NetBeans,
Ant e Java 2 Micro Edition Wireless
Toolkit.
Programação
Requer alguma experiência
em programar em .NET
Requer alguma experiência
programar em Java
Web Services
Suporte integrado a
Compact Framework.
Suporte
através
dos
opcionais KSOAP e KXML
Linguagem
Plataformas
Biblioteca de
Classes
Ferramentas
.NET
em
pacotes
A Tabela 3 apresenta algumas semelhanças e divergências existentes
entre as plataformas .NET CF e J2ME. A .NET CF possui um ambiente de
desenvolvimento mais completo e atinge um número mais amplo de dispositivos,
em relação a J2ME. O fato da J2ME dividir o desenvolvimento em duas
configurações, CDC e CLDC, os ambientes de desenvolvimento também se
diferem pelo fato de que a CDC engloba dispositivos com um poder maior de
processamento e a CLDC dispositivos com menor poder de processamento. O
ambiente
completo
de
desenvolvimento
da
.NET
CF
implica
em
um
desenvolvimento com um custo mais elevado do que a da J2ME, pelo fato da
ferramenta e seus recursos possuírem um custo elevado, além de dispor, por
exemplo, de especificações desnecessárias para o desenvolvimento de
aplicações para dispositivos móveis com um menor poder de processamento. Já
a J2ME possui um grande número de ferramentas livres e suas especificações de
desenvolvimento vão de acordo com o tipo de aplicação a ser criada.
56
5.
CONSIDERAÇÕES FINAIS
Um dos motivos da grande popularização dos dispositivos móveis é a
necessidade do ser humano de permanecer informado a qualquer hora e em
qualquer lugar. Visando atender a essas necessidades, grandes empresas da
informática estão investindo cada vez mais em tecnologias para desenvolvimento
de aplicações para dispositivos móveis. Exemplos disso, são a Sun Microsystem
e a Microsoft, que desenvolveram uma versão de suas plataformas de
desenvolvimento, exclusiva para dispositivos móveis, a J2ME e .NET Compact
Framework. Desta forma, este trabalho apresentou um estudo sobre as
plataformas .NET CF e J2ME, mostrando os recursos básicos para o
desenvolvimento de aplicações para dispositivos móveis, obtendo assim, uma
base para a realização de um comparativo, entre as plataformas..
A plataforma .NET CF é um ambiente que permite construir aplicações
para dispositivos móveis. A execução das aplicações .NET CF é realizada na
CLR, criando um arquivo único e é este arquivo que será executado pelo
emulador. A J2ME também é um ambiente que permite a construção de
aplicações para dispositivos móveis. Os dispositivos alvos desta plataforma são
definidos em duas configurações, CDC (maior poder de processamento) e CLDC
(menor poder de processamento). Para que uma aplicação J2ME possa ser
executada pelo emulador é necessário o arquivo .JAR, gerado por meio da
compilação da aplicação.
As bibliotecas de classes apresentaram semelhanças quanto aos
componentes que às mesmas possuem. O objetivo da biblioteca de classes do
.NET CF é similar ao objetivo das configurações do J2ME, porém, a diferença é
que a biblioteca de classes da .NET CF não incluem especificações de máquina
57
virtual. A .NET CF engloba dispositivos com maior e menor poder de
processamento, porém, os componentes requeridos por aplicações com um poder
maior de processamento não são os mesmos usados por dispositivos com menor
poder de processamento, esta característica implica dizer que a plataforma .NET
CF torna o desenvolvimento de aplicações para dispositivos de pequeno porte
muito caro, pelo fato de dispor de especificações desnecessárias para o
desenvolvimento destas aplicações.
Ao contrário da .NET CF, a J2ME possui dois tipos de configurações que
definem as características dos dispositivos móveis, a CDC e a CLDC. A CDC
engloba dispositivos com maior poder de processamento, e dispõe de
componentes específicos para esta característica de dispositivo. Os componentes
apresentados da configuração CLDC, englobam dispositivos com menor poder de
processamento, configuração esta usada como exemplo neste trabalho.
O uso de Web Services pelas aplicações para dispositivos móveis é
interessante do ponto de vista tecnológico e econômico, uma vez que estas
aplicações não se preocupam em mudar plataformas de desenvolvimento,
sistemas operacionais e linguagem de programação para se adaptarem aos
serviços oferecidos pelos Web Services. Pois, os Web Services independem de
plataformas e os serviços oferecidos são garantidos pela interoperabilidade.
A
realização
deste
trabalho
permitiu
demonstrar
as
principais
características das plataformas .NET Compact Framework e J2ME no
desenvolvimento de aplicações para dispositivos móveis, o uso da tecnologia
Web Services pelas plataformas .NET CF e J2ME. Além de demonstrar os
recursos, foi criada uma aplicação J2ME CLDC/MIDP, permitindo exemplificar as
funcionalidades da plataforma J2ME. O desenvolvimento da aplicação não
apresenta grandes dificuldades, sendo bastante semelhante ao desenvolvimento
de aplicações desktop e Web.
Através dos estudos comparativos realizados pôde-se analisar que as
plataformas .NET CF e J2ME apresentam características semelhantes e
divergentes em relação ao desenvolvimento de aplicações para dispositivos
móveis, como ferramentas, ambiente de execução, linguagens, suporte a Web
Services, entre outras características. Ao comparar as duas plataformas, a J2ME
mostra uma vantagem competitiva em relação a .NET CF, visto que a primeira
58
coisa que uma empresa analisa ao adotar um produto é a redução dos gastos
com desenvolvimento. A J2ME oferece mais opções de ferramentas livres, código
aberto e portabilidade, por outro lado, a plataforma .NET CF foca em
produtividade e um ambiente de desenvolvimento integrado. Assim, a partir dos
estudos realizados neste trabalho, foi possível identificar, analisar e escolher qual
das plataformas de desenvolvimento são mais viáveis no desenvolvimento de
aplicações para dispositivos móveis, tanto para uso comercial quanto pessoal.
59
REFERÊNCIAS BIBLIOGRÁFICAS
(ALCÂNTARA & INDRUSIAK, 2001) ALCÂNTARA, Giuliana; INDRUSIAK,
Leandro.
Wireless
Java.
2001.
Disponível
em:
<http://www.wirelessbrasil.org/wirelessbr/colaboradores/indrusiak/wirelessjava.html>
(ALECRIM, 2004) Máquina Virtual Java (Java Virtual Machine). Disponível em:
< http://www.infowester.com/jvm.php>
(ALMEIDA, 2005) ALMEIDA, Leandro Batista. Programação MIDP em J2ME.
Junho,
2005.
Disponível
em:
<http://www.enterpriseguys.com/Artigos.aspx?ColunistaID=18&id=68>
(AVELINO, 2004) AVELINO, Jones. Consumindo um Web Service através de
uma Aplicação ASP.NET para Dispositivos Móveis. 2004. Disponível em:
<http://www.linhadecodigo.com.br/artigos.asp?id_ac=686&pag=4>
(BURÉGIO, 2003) BURÉGIO, Vanilson André de Arruda. Desenvolvimento de
Aplicações para Dispositivo Móveis com .Net. Trabalho de Graduação
Universidade Federal de Pernambuco Graduação em Ciência da Computação
Centro
de
Informática.
Agosto,
2003.
Disponível
em:
<http://www.cin.ufpe.br/~tg/2003-1/vaab>
(CARDOSO, 2005) CARDOSO, Jorge. Java para Telemóveis – MIDP 2.0. Abril,
2005. Disponível em: <http://livromidp.jorgecardoso.org/conteudos.php>
60
(DUKE, 2003) DUKE. Linguagem Java. Junho, 2003. Disponível em:
<http://www.infowester.com/lingjava.php>
(FONSECA, 2002) FONSECA, Jorge Cavalcanti. Portando a KVM. Trabalho de
Conclusão de Curso (Graduação em Ciências da Computação) – Centro de
Informática, Universidade Federal de Pernambuco, Recife, 2002. Disponível em:
<www.cin.ufpe.br/~tg/2002-1/jcbf.doc>
(GALVIN, 2004) GALVIN, Deleon. Protótipo de sistema de CRM para
dispositivos móveis utilizando a tecnologia .NET. Trabalho de Conclusão de
Curso (Bacharelado em Ciências da Computação) – Centro de Ciências Exatas e
Naturais, Universidade Regional de Blumenau, Blumenau, 2004. Disponível em:
<www.inf.furb.br/~pericas/orientacoes/CRMPDA2004.pdf>
(GLOSSÁRIO,
2006).
GLOSSÁRIO.
API.
Disponível
em:
<http://gigaflops.tripod.com/page/glossario/A/api.html>
(GUMZ, 2005) GUMZ, Rafael Araújo. Protótipo de um sistema gerador de
interfaces gráficas para testes de Java Web Services. Monografia de PósGraduação (Pós-Graduação em Desenvolvimento de Aplicações para WEB) Centro de Ciências Exatas e Naturais, Universidade Regional de Blumenau,
Blumenau, 2005.
(HADDAD, 2002) HADDAD, Renato. Aplicações móveis para telefones
celulares
com
ASP.NET.
2002.
Disponível
em:
<http://www.microsoft.com/brasil/msdn/tecnologias/movel/mobilidade_aspnet.asp>
(JUNIOR, 2006) JUNIOR, Almir Farias Rivas. .NET Framework e CLR – Visão
Geral.
Fevereiro,
2006.
Disponível
em:
<http://www.juliobattisti.com.br/tutoriais/almirrivas/vbdotnet001.asp>
(MCHUGH, 2003) MCHUGH, Jeff. KSOAP. Agosto, 2003. Disponível em:
<http://ksoap.objectweb.org>
61
(MIRANDA, 2004) MIRANDA, Luiz Henrique. Introdução ao mundo móvel.
Maio, 2004. Disponível em: <http://www.devgoiania.NET>
(MSDN,
2003)
.NET
Framework,
dezembro
de
2005.
Disponível
em:
<http://www.microsoft.com/brasil/msdn/Tecnologias/netframework/Default.mspx>
(NETO, 2003) NETO, Agostinho Campos. . Web Services em Java com Axis:
Teoria
e
Prática.
Disponível
em:
<http://www.guj.com.br/content/articles/webservices/ws.pdf>
(OLIVEIRA, 2004) OLIVEIRA, Eric C. M. Web Services: Java e XML juntos pela
interoperabilidade.
Novembro,
2004.
Disponível
em:
<www.linhadecodigo.com.br/artigos.asp?id_ac=378 >
(PINHEIRO, 2003) PINHEIRO, Christiano. J2ME - Java para os portáteis.
Novembro de 2003. <http://www.imaster.com.br/artigo.php?cn=1539&cc=19>
(SANTOS, 2003) SANTOS, Michael Schuenck. Utilização de Web Services na
plataforma .NET para a criação de um aplicativo visualizador de notícias
para dispositivos móveis. Trabalho de Conclusão de Curso do curso de
Sistemas de Informação, Centro Universitário Luterano de Palmas, 2003.
(SCHMITT, 2004), Arno José Júnior. Protótipo de front end de controle de
acesso usando J2ME. Trabalho de Conclusão de Curso (Bacharelado em
Ciências da Computação) - Centro de Ciências Exatas e Naturais, Universidade
Regional
de
Blumenau,
Blumenau,
2004.
Disponível
em:
<www.inf.furb.br/interno.php?secao=504>
(SILVA, 2006) SILVA, Katia Gomes. Programação para Dispositivos Móveis
com a Plataforma .Net. Trabalho de Estágio do curso de Sistemas de
Informação, Centro Universitário Luterano de Palmas, 2003.
62
(SILVA, 2001) SILVA, Wellington João da. Tecnologia Java para Sistemas
Embarcados. Trabalho de Graduação em Ciência da Computação. Julho, 2001.
Disponível em: <http://www.cin.ufpe.br/~tg/2001-1/wjs.doc>
(SILVEIRA, 2003) SILVEIRA, I. F. Linguagem Java: Java, das torradeiras à
Internet. Junho, 2003. Disponível em: <http://www.infowester.com/lingjava.php>
(SOAP, 2003) SOAP Version 1.2 Part 0: Primer. Novembro, 2003. Disponível
em: <http://www.w3.org/TR/SOAP>
(SUN, 2003) Tutorial Java Web Service. Março, 2003. Disponível em:
<http://java.sun.com/webservice/docs/1.6/tutorial/doc>
(SUN,
2004)
Java
Technology.
Outubro,
2004a.
Disponível
em:
<http://java.sun.com/javaee/>
______. Java 2 Platform, Micro Edition. Outubro, 2004b. Disponível em:
<http://java.sun.com/j2me/>.
______.
What's
New
in
MIDP
2.0.
Outubro,
2004c.
Disponível
em:
<http://developers.sun.com/techtopics/mobility/midp/articles/midp20/>
(SUN, 2005) Introduction to Java 2 Platform Micro Edition and KVM. 2005a.
Disponível em: <http://www.sun.java.com/products/cldc/wp/KVMwp.pdf>
______. Connected, Limited Device Configuration and Mobile Information
Device Profile. 2005b. Disponível em: <http://:java.sun.com/j2me>
(UDDI, 2003) UDDI.org. UDDI.org. 2003. Disponível em: <http://www.uddi.org>
(XML,
2003)
Extensible
<http://www.w3.org/XML/>
Markup
Language.
2003.
Disponível
em:
63
(WAP, 2004) WAP (Wireless Aplication Protocol). Dezembro, 2005. Disponível
em: < http://www.gta.ufrj.br/~granato/WAP2001.html >
(WSDL, 2003) Web Services Description Language (WSDL) Version 2.0 Part
1: Core Language. World Wide Web Consortium, Novembro, 2003. Disponível
em <http://www.w3.org/TR/wsdl20/>
(YUAN, 2003) YUAN, Michael Juntao. Let the Mobile Games Begin. Maio, 2003.
disponível
wireless.html>
em:
<http://www.javaworld.com/javaworld/jw-05-2003/jw-0516-