TCC II - Luis Fabio Faccin

UNIJUI - UNIVERSIDADE REGIONAL DO NOROESTE DO ESTADO DO RIO
GRANDE DO SUL
DETEC – DEPARTAMENTO DE TECNOLOGIA
AMBIENTE PARA DESENVOLVIMENTO DE
APLICATIVOS PARA DISPOSITIVOS MÓVEIS COM
SISTEMA OPERACIONAL SYMBIAN
LUIS FABIO FACCIN
Ijuí
Novembro/2010
2
UNIJUI - UNIVERSIDADE REGIONAL DO NOROESTE DO ESTADO DO RIO
GRANDE DO SUL
DETEC – DEPARTAMENTO DE TECNOLOGIA
AMBIENTE PARA DESENVOLVIMENTO DE
APLICATIVOS PARA DISPOSITIVOS MÓVEIS COM
SISTEMA OPERACIONAL SYMBIAN
LUIS FABIO FACCIN
Trabalho de Conclusão de Curso
apresentado ao Curso de Informática Sistemas de Informação do Departamento
de Tecnologia (DeTec), da Universidade
Regional do Noroeste do Estado do Rio
Grande do Sul (UNIJUÍ), como requisito
para a obtenção do título Bacharel em
Informática - Sistemas de Informação.
Orientador: Prof. Dr. Paulo Sérgio Sausen
Ijuí
Novembro/2010
3
AMBIENTE PARA DESENVOLVIMENTO DE APLICATIVOS
PARA DISPOSITIVOS MÓVEIS COM SISTEMA
OPERACIONAL SYMBIAN
LUIS FABIO FACCIN
Trabalho de Conclusão de Curso apresentado
ao Curso de Informática - Sistemas de
Informação do Departamento de Tecnologia
(DeTec), da Universidade Regional do
Noroeste do Estado do Rio Grande do Sul
(UNIJUÍ), como requisito para a obtenção do
título Bacharel em Informática - Sistemas de
Informação.
______________________________________
Orientador: Prof. Dr. Paulo Sérgio Sausen
BANCA EXAMINADORA
______________________________________
Prof. Dr. Sandro Sawicki
Ijuí
Novembro/2010
4
DEDICATÓRIA
Dedico este trabalho aos meus pais Neimar e Marlei
que sempre estiveram ao meu lado, me incentivando, apoiando
e ajudando em todos os momentos. Pais que foram amigos e
fiéis conselheiros, que acima de tudo me encorajaram a seguir
em frente e a conquistar meus sonhos. Dedico também à
minha irmã Luciele, pelo carinho. À minha namorada Elenise,
pelo amor, dedicação e tudo que vivemos juntos durante essa
etapa, e para os meus familiares que mesmo longe me
apoiaram.
5
AGRADECIMENTOS
Agradeço a Deus por ter iluminado meus caminhos, e me ajudado a chegar
até aqui.
Aos meus pais que muitas vezes abriram mão dos seus sonhos e objetivos
para que eu pudesse conquistar os meus.
À minha irmã que mesmo com a inocência de criança me ajudou.
À minha namorada pelo incentivo aos meus estudos e na busca de meus
ideais.
Ao meu orientador Paulo Sérgio Sausen que sempre me ajudou a sanar
minhas dúvidas durante este trabalho e aprimorar meus conhecimentos em redes de
computadores.
Ao professor Sandro Sawicki, que gentilmente aceitou o convite para ser
banca na defesa do meu trabalho de conclusão de curso.
Aos meus colegas por todos os anos de convivência e amizade.
À gurizada do GAIC pela parceria e todos os bons momentos e histórias que
vivemos juntos ao longo de muitas tardes, noites e até madrugadas como bolsistas.
À todos os professores de Informática pelos conhecimentos à nós
seriamente repassados.
Aos meus familiares que me auxiliaram em todos os momentos.
6
“O insucesso é apenas uma oportunidade para
recomeçar de novo com mais inteligência”.
Henry Ford
7
RESUMO
O presente trabalho aborda, inicialmente, um estudo sobre o desenvolvimento de
software para telefones celulares que utilizam o sistema operacional Symbian. O
mercado de dispositivos móveis vem crescendo, onde milhares de novos
dispositivos são vendidos todos os dias. Este aumento de vendas, aliado ao
crescimento da capacidade de processamento despertou o interesse das empresas
em utilizar estes dispositivos móveis em seu benefício, através do desenvolvimento
de aplicativos adequados à seu tipo de atividade. Neste sentido, este trabalho
apresenta o sistema operacional Symbian e suas características, juntamente com as
principais ferramentas e tecnologias disponíveis para o desenvolvimento de
aplicativos para celular, utilizando a plataforma Java 2 Micro Edition. Também são
apresentadas as estruturas e tecnologias que envolvem os recursos necessários
para efetuar a comunicação destes dispositivos móveis com servidores remotos
através de Web Services. O estudo de caso apresenta um protótipo desenvolvido
para monitorar remotamente as atividades de uma subestação de energia elétrica, o
qual possibilita melhorias no controle de qualidade da energia elétrica fornecida pela
subestação aos consumidores.
Palavras-chave: Symbian, J2ME, MIDP, telefones celulares, Web Services,
Monitoramento Remoto.
8
LISTA DE ABREVIATURAS E SIGLAS
AMS - Application Management Software
API - Application Programming Interface
ASF - Apache Software Foundation
AWT - Abstract Window Toolkit
CDC - Connected Device Configuration
CLDC - Connected Limited Device Configuration
FP - Foundation Profile
GAIC - Grupo de Automação Industrial e Controle
GUI - Graphical user interface - Interface gráfica do usuário
IDE - Ambiente Integrado de Desenvolvimento
J2ME - Java2 Micro Edition
JAD - Java Application Descriptor
JAR - Java Archive
JCP - Java Community Proccess
JDBC - Java Database Connectivity
JDK - Java Development Kit
JMS - Java Message Service
JSP - JavaServer Pages
JSR - Java Specification Request
JVM - Java Virtual Machine
JWS - Java Web Service
KVM - Kilobyte Virtual Machine
MIDP - Mobile Information Device Profile
PBP - Personal Basis Profile
PP - Personal Profile
RMI - Remote Method Invocation
SDK - Software Development Kit
SGBD - Sistema de Gerenciamento de Banco de Dados
9
SGML - Standart Generalized Markup Language
SO - Sistema Operacional
SOAP - Simple Object Access Protocol
SR - Servidor Remoto
UDDI - Universal Description Discovery and Integration
UIQ - User Interface Quartz
URAD - Unidade Remota de Aquisição de Dados
URI - Identificador Uniforme de Recursos
WS - Web Service
WSDD - Web Service Deployment Descriptor
WSDL - Description Language
WTK - Wireless ToolKit
WWW - World Wide Web
XML - Extended Markup Language
10
LISTA DE FIGURAS
Figura 1 - Exemplos de Telefones Celulares da série S60. ...................................... 25
Figura 2 - Nokia 9210i, com SO da Série 80. ............................................................ 26
Figura 3 - Motorola Z10 com interface UIQ. .............................................................. 26
Figura 4 - Arquitetura J2ME ...................................................................................... 29
Figura 5 - Ciclo de vida de um MIDlet ....................................................................... 38
Figura 6 - Hierarquia de Classes de interface gráfica do MIDP................................. 41
Figura 7 - Seleção da JDK para download. ............................................................... 49
Figura 8 - Seleção de plataforma e idioma do JDK. .................................................. 49
Figura 9 - Link para download do JDK. ..................................................................... 49
Figura 10 - Variáveis de ambiente do Windows. ....................................................... 50
Figura 11 - Verificando a instalação do Java............................................................. 50
Figura 12 - Versões do Netbeans.............................................................................. 52
Figura 13 - Localização do JDK durante a instalação do Netbeans. ......................... 52
Figura 14 - Tela principal do Netbeans 6.9.1............................................................. 53
Figura 15 - Novo projeto no Netbeans. ..................................................................... 54
Figura 16 - Seleção do tipo de projeto no Netbeans. ................................................ 55
Figura 17 - Propriedades da nova aplicação no Netbeans. ....................................... 56
Figura 18 - Seleção da Plataforma no Netbeans....................................................... 57
Figura 19 - Configurações finais do projeto. .............................................................. 57
Figura 20 - Exibição do projeto criado no Netbeans.................................................. 58
Figura 21 - Criação de um MIDlet no projeto do Netbeans. ...................................... 59
Figura 22 - MIDlet criado no projeto. ......................................................................... 59
Figura 23 - MIDlet sendo executado no emulador do WTK. ...................................... 61
Figura 24 - Emulador da Nokia S60 3rd Edition FP2 SDK ........................................ 63
Figura 25 - Download do SDK Nokia S60 3rd Edition FP2 ........................................ 64
11
Figura 26 - Solicitação de instalação do ActivePerl................................................... 64
Figura 27 - Adicionar Plataforma ao Netbeans.......................................................... 65
Figura 28 - Tipos de Plataformas no Netbeans. ........................................................ 66
Figura 29 - Seleção de plataforma para execução do MIDlet. .................................. 66
Figura 30 - MIDlet sendo executado no emulador do S60. ....................................... 67
Figura 31 - MIDlet sendo executado no celular Nokia N81 ....................................... 67
Figura 32 - Configuração de plataforma no projeto do Netbeans. ............................. 68
Figura 33 - Exemplo TextBox .................................................................................... 70
Figura 34 - Exemplo List Exclusive, Multiple e Implicit .............................................. 71
Figura 35 - Exemplo Alert - Erro ................................................................................ 72
Figura 36 - Exemplo ChoiceGroup ............................................................................ 73
Figura 37 - Exemplo DateField .................................................................................. 74
Figura 38 - Exemplo TextField. ................................................................................. 75
Figura 39 - Exemplo Gauge. ..................................................................................... 75
Figura 40 - Exemplo ImageItem. ............................................................................... 76
Figura 41 - Exemplo StringItem ................................................................................. 77
Figura 42 - Exemplo de aplicação: Somar dois números .......................................... 79
Figura 43 - Visão Geral do Ambiente de Desenvolvimento ....................................... 79
Figura 44 - Download do Apache Tomcat 7 .............................................................. 87
Figura 45 - Download do Apache Axis 1.4 ................................................................ 87
Figura 46 - Iniciar/parar Apache Tomcat. .................................................................. 88
Figura 47 - Exemplo de aplicação: Somar dois números utilizando Web Services ... 92
Figura 48 - Arquitetura do Sistema de Monitoramento de Subestações de Energia
Elétrica ...................................................................................................................... 94
Figura 49 - Unidade Remota de Aquisição de Dados (URAD) .................................. 95
Figura 50 - Servidor Remoto (SR) ............................................................................. 95
Figura 51 - Tela do aplicativo de monitoramento ...................................................... 96
Figura 52 - Diagrama de telas da aplicação de monitoramento ................................ 98
Figura 53 - Menu da aplicação de Monitoramento .................................................... 99
Figura 54 - Gráficos gerados pela aplicação de Monitoramento ............................. 100
Figura 55 - Configurações do aplicativo de Monitoramento .................................... 102
12
LISTA DE QUADROS
Quadro 1 - Código fonte Aplicação de Exemplo........................................................ 60
Quadro 2 - Código fonte TextBox .............................................................................. 70
Quadro 3 - Código fonte List ..................................................................................... 71
Quadro 4 - Código fonte Alert.................................................................................... 72
Quadro 5 - Código fonte ChoiceGroup ...................................................................... 73
Quadro 6 - Código fonte DateField............................................................................ 74
Quadro 7 - Código fonte TextField ............................................................................ 75
Quadro 8 - Código fonte Gauge ................................................................................ 75
Quadro 9 - Código fonte ImageItem .......................................................................... 76
Quadro 10 - Código fonte exemplo de aplicação que soma dois números ............... 78
Quadro 11 - WSDL do Web Service.......................................................................... 89
Quadro 12 - XML com a resposta da chamada de um método do WS pelo Browser89
Quadro 13 - Código fonte da aplicação de exemplo com WS ................................... 92
Quadro 14 - Método do WS da aplicação de Monitoramento .................................. 101
13
LISTA DE TABELAS
Tabela 1 - Volume de vendas de Smartphones ........................................................ 21
Tabela 2 - Comparação entre perfis das configurações CDC e CLDC ..................... 35
Tabela 3 - Pacotes da API microedition. ................................................................... 36
Tabela 4 - Pacotes adicionais do CLDC. ................................................................... 37
Tabela 5 - Tipos de Command .................................................................................. 43
14
SUMÁRIO
INTRODUÇÃO .......................................................................................................... 17
1.
SYMBIAN ........................................................................................................... 20
1.1. Histórico ...................................................................................................... 22
1.2. Arquitetura .................................................................................................. 23
1.3. Interfaces do usuário do Sistema Operacional Symbian............................. 24
1.3.1.
S60 ...................................................................................................... 25
1.3.2.
Série 80 ............................................................................................... 25
1.3.3.
User Interface Quartz (UIQ) ................................................................. 26
1.4. Linguagens de programação suportadas .................................................... 27
2.
J2ME – JAVA 2 MICRO EDITION ..................................................................... 28
2.1. Arquitetura do J2ME ................................................................................... 28
2.2. Configurações ............................................................................................. 30
2.2.1.
Connected Limited Device Configuration (CLDC) ................................ 30
2.2.2.
Connected Device Configuration (CDC) .............................................. 31
2.3. Perfis ........................................................................................................... 32
2.3.1.
Foundation Profile (FP) ........................................................................ 33
2.3.2.
Personal Basis Profile (PBP) ............................................................... 33
2.3.3.
Personal Profile (PP) ........................................................................... 33
2.3.4.
Mobile Information Device Profile (MIDP) ............................................ 34
3.
MOBILE INFORMATION DEVICE PROFILE - MIDP......................................... 36
3.1. API microedition .......................................................................................... 36
3.2. MIDlets ........................................................................................................ 37
3.2.1.
Ciclo de vida de um MIDlet .................................................................. 37
3.3. Midlets Suite ............................................................................................... 40
4.
INTERFACE GRÁFICA DE UM MIDLET ........................................................... 41
4.1. Display ........................................................................................................ 42
4.2. Displayable – Interface com o usuário de alto nível .................................... 42
4.3. Command ................................................................................................... 42
4.4. Ticker .......................................................................................................... 43
4.5. Screen......................................................................................................... 43
15
4.5.1.
TextBox ................................................................................................ 43
4.5.2.
List ....................................................................................................... 44
4.5.3.
Alert ..................................................................................................... 44
4.5.4.
Form .................................................................................................... 44
4.5.5.
Item ...................................................................................................... 45
4.5.5.1. ChoiceGroup .................................................................................... 45
4.5.5.2. DateField.......................................................................................... 45
4.5.5.3. TextField .......................................................................................... 46
4.5.5.4. Gauge .............................................................................................. 46
4.5.5.5. ImageItem ........................................................................................ 46
4.5.5.6. StringItem......................................................................................... 46
4.6. Canvas – Interface com o usuário de baixo nível ....................................... 47
4.6.1.
Graphics .............................................................................................. 47
5.
AMBIENTE DE DESENVOLVIMENTO .............................................................. 48
5.1. JDK - Java Development Kit ....................................................................... 48
5.1.1.
Baixando e instalando o JDK ............................................................... 48
5.1.2.
Configurando as variáveis de ambiente ............................................... 50
5.2. IDE Netbeans 6.9.1 ..................................................................................... 51
5.2.1.
Download e instalação do Netbeans 6.9.1 ........................................... 51
5.2.2.
Wireless Toolkit.................................................................................... 53
5.2.3.
Por que utilizar o Netbeans? ................................................................ 54
5.3. Criando um novo projeto no Netbeans 6.9.1............................................... 54
5.4. Executando a aplicação no Wireless Toolkit (WTK).................................... 61
5.5. Software Development Kit (SDK) ................................................................ 62
5.5.1.
Software S60 3rd Edition FP2 SDK ..................................................... 62
5.5.2.
Download e instalação do SDK S60 3rd Edition, FP2.......................... 63
5.5.3.
Adicionando a plataforma S60 ao Netbeans ........................................ 65
5.5.4.
Executando a aplicação na Plataforma S60 ........................................ 66
5.5.5.
Utilizando os elementos visuais de alto nível ....................................... 69
5.5.5.1. TextBox ............................................................................................ 69
5.5.5.2. List ................................................................................................... 71
5.5.5.3. Alert.................................................................................................. 72
5.5.5.4. Form (e seus “Items”)....................................................................... 72
5.5.6.
Exemplo de aplicação: Somar dois números ....................................... 77
5.6. Visão Geral do Ambiente de Desenvolvimento ........................................... 79
6.
WEB SERVICES ................................................................................................ 80
6.1. Utilização .................................................................................................... 81
6.2. Tecnologias................................................................................................. 81
6.2.1.
XML ..................................................................................................... 81
6.2.2.
SOAP ................................................................................................... 82
6.2.3.
WSDL .................................................................................................. 82
6.2.4.
UDDI .................................................................................................... 83
6.3. Arquitetura Básica dos Web Services ......................................................... 84
16
6.4. Vantagens ................................................................................................... 84
6.5. Desvantagens ............................................................................................. 85
6.6. Apache Tomcat v.7 ..................................................................................... 85
6.7. Apache Axis v1.4 ........................................................................................ 86
6.8. Instalação do Apache Tomcat e Apache Axis ............................................. 86
6.9. Desenvolvendo um Web Service simples ................................................... 88
6.10.
Exemplo de aplicação: Somar dois números utilizando WS .................... 90
6.10.1. kSOAP e kXML .................................................................................... 90
6.10.2. Modificando o projeto para conectar ao Web Services ........................ 90
7. ESTUDO DE CASO: ADIÇÃO DE UM MÓDULO MÓVEL AO SISTEMA DE
MONITORAMENTO EM SUBESTAÇÕES DE ENERGIA ELÉTRICA ..................... 93
7.1. Sistema De Monitoramento Em Subestações De Energia Elétrica ............. 93
7.1.1.
Subsistema De Aquisição De Dados ................................................... 94
7.1.2.
Subsistema Servidor Remoto .............................................................. 95
7.1.3.
Subsistema Controlador Supervisório .................................................. 96
7.2. Protótipo Do Subsistema Móvel Incorporado .............................................. 97
7.2.1.
Funcionamento Geral Da Aplicação .................................................... 97
7.2.2.
Menu .................................................................................................... 98
7.2.3.
Gráficos ............................................................................................... 99
7.2.4.
Conexão com o Web Services ........................................................... 100
7.2.5.
Configurações .................................................................................... 102
7.2.6.
Outras tecnologias utilizadas ............................................................. 102
7.3. Considerações Finais do Protótipo Desenvolvido ..................................... 103
CONCLUSÃO ......................................................................................................... 105
Trabalhos Futuros ................................................................................................ 106
REFERÊNCIAS BIBLIOGRÁFICAS ....................................................................... 107
17
INTRODUÇÃO
É notável, a cada dia, o avanço tecnológico que certos dispositivos vêm
sofrendo. A utilização de telefones celulares e suas tecnologias estão cada vez mais
presentes na vida do ser humano que, hoje, utiliza estas tecnologias como uma
necessidade, e não mais apenas como uma mera novidade. O uso destas
tecnologias possibilita a realização de tarefas que antes só poderiam ser feitas com
o auxílio de computadores tradicionais.
Com o intuito de aproveitar a capacidade computacional dos dispositivos
móveis, as empresas buscam soluções que possam integrar e melhorar as
atividades de seu dia-a-dia. Grandes empresas da informática investem cada vez
mais no desenvolvimento de software para telefones celulares, como por exemplo, a
Sun Microsystem, a qual desenvolveu uma versão reduzida de sua plataforma Java,
o Java 2 Micro Edition (J2ME), justamente para atender a demanda para estes
pequenos dispositivos.
O Java difere de outras linguagens de programação, pois possui recursos de
Orientação a Objetos, proporcionando códigos portáveis, reusáveis e robustos,
bastando ter disponível nos dispositivos móveis, uma Máquina Virtual.
A objetivo inicial deste trabalho de conclusão de curso é realizar um estudo
de caráter exploratório, a fim de se obter base teórica sobre ferramentas existentes,
juntamente com informações sobre o ambiente de desenvolvimento de softwares
para celular que utilizam o Sistema Operacional Symbian, através de revisão
bibliográfica em livros, trabalhos publicados e na internet. Após essa fase, o trabalho
18
possui caráter explicativo, pois demonstra como utilizar as ferramentas e recursos
pesquisados.
Após a fase exploratória, o trabalho apresenta um estudo de caso, onde será
desenvolvido o protótipo de um Subsistema Móvel para o Sistema de Monitoramento
em uma Subestação de Energia Elétrica, cuja finalidade será desenvolver um
aplicativo para telefones celulares para obter dados e monitorar as atividades da
subestação de energia remotamente.
O estudo de caso foi aplicado a um projeto de pesquisa de iniciação
científica junto ao GAIC – Grupo de Automação Industrial e Controle, que é um
grupo de pesquisas nas áreas de Engenharia Elétrica e Informática, localizada do
DETEC – Departamento de Tecnologia, da Universidade Regional do Noroeste do
Estado do Rio Grande do Sul, conforme o Capítulo 7.1.
A estrutura do trabalho divide-se em sete capítulos. O primeiro deles
aborda o Sistema Operacional para telefones celulares, o Symbian. Apresenta seu
histórico, sua arquitetura, as séries existentes, e ainda, uma breve análise de
mercado.
O Segundo capítulo aborda uma breve explanação da tecnologia Java 2
Micro Edition, com sua arquitetura, configurações e perfis.
O terceiro capítulo refere-se ao perfil Mobile Information Device Profile
(MIDP), apresentando o ciclo de vida das aplicações, perfil este, que será utilizado
para a construção de aplicativos para os telefones celulares.
O quarto capítulo apresenta detalhadamente cada um dos elementos
disponíveis para criar a interface gráfica para que os usuários possam interagir com
a aplicação.
O quinto capítulo descreve como adquirir, instalar e utilizar as ferramentas
disponíveis para o desenvolvimento. Também mostra como utilizar os elementos de
interface gráfica, descritos no capítulo quatro.
19
O sexto capítulo, por sua vez, contém informações referentes aos Web
Services. Apresenta exemplos de utilização, tecnologias, arquitetura, vantagens,
desvantagens e as ferramentas utilizadas para disponibilizar os serviços do Web
Service.
O último capítulo demonstra a produção do aplicativo utilizado no estudo de
caso. Apresenta os recursos utilizados e seu funcionamento e os resultados obtidos
com a implantação deste protótipo.
Por fim, são apresentadas as conclusões do trabalho e as referências bibliográficas
consultadas.
20
1. SYMBIAN
Symbian é o Sistema Operacional (SO) desenvolvido para telefones
celulares utilizados por diversos fabricantes como: Nokia, Sony Ericsson, Panasonic,
Motorola e Samsung. É um SO desenvolvido para telefone celulares do tipo
“multimídia”, ou seja, celulares que suportam o uso de câmeras fotográficas,
mensagens do tipo SMS e MMS, wireless, bluetooth, vídeos, músicas, entre outras
funções, as quais se tornam muito importantes quando o assunto tratado é
mobilidade.
Por ser um SO que controla muito bem o consumo de memória, o consumo
de energia, o processamento, entre outros fatores essenciais as empresas mais
poderosas da telecomunicação investiram muito para que este fosse um SO propício
para o mercado.
Notícias recentes publicadas em um dos portais sobre Mobilidade [1] indicam
que as empresas Sony Ericsson e Samsung abandonaram a utilização do SO
Symbian em seus novos telefones celulares. A Sony Ericsson afirma que “não tem
planos para desenvolver nenhum novo produto para o padrão ou sistema
operacional da Fundação Symbian” enquanto o foco da Samsung será utilizar seu
novo SO lançado em 2009, conhecido como “Bada”, já disponível no dispositivo
“Samsung Wave S8500”. Mesmo sem utilizar o SO Symbian, as duas empresas
ainda serão membros da Fundação Symbian, a qual é mantenedora oficial deste
SO, apenas para manter as aparências.
Apesar de uma considerável queda na utilização do Symbian como SO nos
dispositivos móveis devido aos SOs concorrentes, uma pesquisa realizada pela
21
Revista Info [2] demonstrou que em 2010 o Symbian abrange uma fatia de cerca de
37% no mercado de smartphones, seguido de suas concorrentes Android com cerca
de 20%, BlackBerry com 17%, Apple iOS com 13%, Windows Mobile e outros com
6%.
Segundo a GARTNER [3], no terceiro quadrimestre de 2010 foram vendidos
417 milhões de unidades de celulares. O que torna evidente a troca dos
computadores, notebooks e netbooks, por aparelhos de menor porte, porém com
poder computacional suficiente para resolver as tarefas diárias dos usuários, como
ler e-mails, navegar na Web, edição básica de textos, etc...
Mesmo com a liderança da Nokia com seus dispositivos com o SO Symbian,
o Android tem subido rapidamente nas quotas de mercado para aderir em menos de
um ano um valor equivalente ao crescimento de 25% nas vendas de todos os
dispositivos vendidos com este sistema operacional. Parte deste crescimento
ocorreu devido à parceria com diversas empresas para desenvolvimento e
distribuição de aparelhos para os diversos nichos do mercado, com exceção dos
dispositivos da Apple (iOS), com distribuição somente por parte desta empresa.
A Tabela 1 apresenta o volume de vendas de Smartphones em unidades e
porcentagem de mercado no terceiro quadrimestre de 2009 e 2010.
Company
3Q10
Units
29,480.1
20,500.0
13,484.4
11,908.3
2,247.9
3Q10 Market Share
(%)
36.6
25.5
16.7
14.8
2.8
3Q09
Units
18,314.8
1,424.5
7,040.4
8,522.7
3,259.9
3Q09 Market Share
(%)
44.6
3.5
17.1
20.7
7.9
2.1
1.5
100.0
1,918.5
612.5
41,093.3
4.7
1.5
100.0
Symbian
Android
iOS
Research In Motion
Microsoft Windows
Mobile
Linux
1,697.1
Other OS
1,214.8
Total
80,532.6
Tabela 1 - Volume de vendas de Smartphones
Fonte: Gartner [3].
22
1.1.
Histórico
Fundada em 1980, a Psion, uma empresa de Hardware iniciou suas
atividades voltadas para Personal Digital Assistants (PDAs). Com o passar dos anos,
houve grandes mudanças, desde a união com outras empresas até o
desenvolvimento
de
sistemas
operacionais
para
celulares.
Alguns
pontos
importantes são listados a seguir, conforme [4].
1980 – Fundada a Psion por David Potter. Psion era uma empresa de Hardware
para PDAs.
Início de 1990 – Criado o EPOC16. Um SO para dispositivos com processadores da
família Intel 8086 com 16 bits.
Década de 90 – Lançado o EPOC32. Um SO com proteção de memória e
multitarefa, também para PDAs. Desenvolvido para família de processadores ARM,
incluindo o ARM7, ARM9, StrongARM e Intel XScale.
1997 – Lançado a versão “Série 5” do EPOC.
1998 – A Psion Software tornou-se Symbian Ltd., juntamente com as empresas
Ericsson, Motorola e Nokia.
2001 – Lançado o SO Symbian 6.0. Fornecia suporte para uma nova gama de
smartphones.
2003 – Lançado o SO Symbian 7.0. Fornecia melhorias na interface com o usuário.
Suporte a câmeras, cartões de memória, melhorias no Bluetooh, porta Infravermelho
e rádio.
2004 – A Psion vendeu sua participação na Symbian. Também foi criado o primeiro
vírus para este SO, chamado de Cabir, o qual se espalhava para outros dispositivos
através de Bluetooth.
2004 – Lançado o SO Symbian 8.0 com duas opções de escolha para o Kernel.
Inclusão de APIs para dar suporte às redes de comunicações CDMA, 3G, internet,
suporte a gráficos e acesso direto da tela dos dispositivos.
2005 – Lançado o SO Symbian 9.1. A versão 9.0 foi utilizada somente para fins
internos da empresa. A versão 9.1 inclui melhorias de segurança.
23
2006 – Lançado Symbian OS 9.2. Uso da “Série 60 da Nokia 3ª Edição”, incluindo os
modelos Nokia E71, Nokia E90, Nokia N95, Nokia N82, Nokia N81 e Nokia 5700.
Julho de 2006 – Lançado o Symbian OS 9.3. Melhoramentos na gestão da memória
e suporte nativo para Wi-Fi 802.11 e HSDPA. Principais modelos: Nokia E72, Nokia
5730 XpressMusic, Nokia N79, Nokia N96, Nokia E52, Nokia E75, Nokia 5320
XpressMusic e Sony Ericsson P1.
Março de 2007 - Lançado o Symbian OS 9.4. As aplicações iniciam até 75% mais
rápidas. Principais modelos: Samsung i8910 Omnia HD, Nokia N97, Nokia N97 mini,
Nokia 5800 XpressMusic, Nokia 5530 XpressMusic, Nokia 5228, Nokia 5230, Nokia
5233, Nokia 5235, Nokia C6-00, Nokia X6, Sony Ericsson Satio, Sony Ericsson Vivaz
e Sony Ericsson Vivaz Pro.
2007 - Lançado o Symbian OS 9.5, com suporte nativo para televisão digital.
2008 – Anúncio da Symbian Ltd. em se transformar em Symbian Foundation. Esta
transformação vigorou em 2009, onde o Symbian tornou-se Software Livre. O
Objetivo era publicar o código fonte de toda plataforma Symbian.
2010 – Primeiro dispositivo (Nokia N8) com suporte a saída Full HD e também foi o
primeiro dispositivo a fazer parte do Symbian^3 (primeira versão completamente
open source do Symbian). Possuem interfaces sensíveis ao toque melhoradas.
Estava previsto para o início de 2011 o lançamento da versão Symbian^4, porém em
outubro de 2010 a Nokia anunciou que não seria lançada esta nova versão, e sim,
apenas melhorias para a versão Symbian^3.
1.2.
Arquitetura
A arquitetura do SO Symbian pode ser definida em seis partes, conforme [5].
Kernel – O Kernel gerencia o SO Symbian.
Ele gerencia a memória e
escalona os programas para execução. Também aloca recursos compartilhados do
sistema do dispositivo móvel e gerencia qualquer funcionalidade que necessite de
acesso privilegiado à CPU.
24
Bibliotecas Básicas – As bibliotecas básicas contêm APIs que oferecem
funcionalidades tais como manipulação de strings, listas, arquivos de entrada/saída,
banco de dados, manipulação de erros e temporizadores. Oferecem também acesso
às funções do kernel, como por exemplo, comunicação entre cliente/servidor. As
bibliotecas não são utilizadas apenas pelas aplicações, e sim, pelo próprio sistema
operacional.
Serviços e Protocolos - Fornecem acesso a serviços e dados de aplicação.
Ex: Manipular dados de contatos, calendários, listas de tarefas, alarmes e até
mesmo comunicação.
Framework
de
aplicação
–
Apresenta
a
estrutura
básica
para
funcionamento da interface gráfica do usuário das aplicações instaladas no
smartphone.
Arquitetura de Comunicação – Consiste em APIs para implementar
comunicação de dados. Inclui comunicação por TCP/IP através da operadora de
telefonia móvel, bem como protocolos de comunicação através de Bluetooth,
infravermelho, USB, SMS, MMS e serviços de e-mail.
Middlewares – Inclui diversas outras APIs para outros tipos de
funcionalidades, como por exemplo, execução/manipulação de conteúdo multimídia.
1.3.
Interfaces do usuário do Sistema Operacional Symbian
As diferentes interfaces de usuário para o SO Symbian foram planejadas e
projetadas para permitir que os fabricantes possam produzir uma gama de telefones
com diferentes estilos. A divisão entre estas interfaces é feita através dos recursos
disponíveis em cada tipo de dispositivo.
Conforme EDWARDS [6], existem três categorias, sendo elas S60
(conhecida como Série 60), Série 80 e UIQ. Havia uma quarta categoria, a Série 90,
porém esta agora faz parte da S60.
25
1.3.1.
S60
S60 é a série constituída por um conjunto de bibliotecas e aplicativos
padrão, destinados a fornecer telefones celulares mais modernos e cheios de
recursos, como telas coloridas maiores, e conteúdo multimidia (i.e. sons, vídeos,
imagens), amplamente conhecidos como smartphones.
Quando falamos em S60 associamos diretamente esta série aos telefones
celulares produzidos pela Nokia, a qual é a maior fabricante que utiliza este SO,
embora esteja licenciada para telefones celulares de outros fabricantes como BenQSiemens, Samsung e Panasonic. A Figura 1 apresenta alguns telefones celulares da
série S60.
A esta série também está atribuida a utilização de um teclado do tipo ITU-T,
o qual é o teclado “tradicional” da maioria dos telefones celulares, composto por
doze teclas, sendo elas os números de 0 à 9, a tecla asterisco (*) e a tecla sustenido
(#).
Figura 1 - Exemplos de Telefones Celulares da série S60.
1.3.2.
Série 80
A série 80 foi projetada principalmente para dispositivos de usuários voltados
a área de negócios, onde é necessário acessar, visualizar e manipular dados
usando telas maiores, com resolução mínima de 640x200px.
26
Também é conhecida pela utilização de teclados completos, do tipo
QWERTY, similar aos teclados utilizados em computadores comuns. Atualmente
somente a Nokia produz telefones para a Série 80, cujo dispositivo é "dobrável",
onde o teclado e a tela maior ficam no interior do aparelho, quando este se encontra
fechado, conforme Figura 2.
Figura 2 - Nokia 9210i, com SO da Série 80.
1.3.3.
User Interface Quartz (UIQ)
Os telefones celulares baseados em UIQ possuem uma interface de usuário
baseada em telas sensíveis ao toque (i.e. touch screen) ou ainda com utilização a
partir de uma caneta. Possuem resolução mínima de 320x240px com no mínimo 12
ou 16 bits de cor.
Os principais dispositivos que utilizam UIQ são produzidos pela Sony
Ericsson, Motorola e BenQ-Siemens. A Figura 3 mostra um modelo produzido
utilizando a interface UIQ. Note que a presença de teclado físico não é obrigatória
nos dispositivos.
Figura 3 - Motorola Z10 com interface UIQ.
27
1.4.
Linguagens de programação suportadas
O SO Symbian é um sistema muito versátil, pois permite a utilização de
várias linguagens de programação para o desenvolvimento dos aplicativos, onde se
destacam o Symbian C/C++, JavaME, FlashLite, Perl, Python, Ruby, Lua e
Acelarometer.
Este trabalho utiliza-se de dispositivos pertencentes à série S60 do Symbian.
Portanto, será utilizada a linguagem de programação Java 2 Micro Edition (J2ME),
pois esta apresenta vários recursos e bibliotecas para o desenvolvimento dos
aplicativos e também por haver uma grande documentação de suporte para esta
linguagem. No Capítulo 2 são abordados, a seguir, detalhes sobre o J2ME.
Este capítulo apresentou uma introdução sobre o sistema operacional
Symbian, seu histórico, arquitetura, suas séries, as quais os telefones celulares se
subdividem e as linguagens de programação suportadas para o desenvolvimento. O
Capítulo 2 apresenta conceitos sobre a linguagem de programação J2ME (Java 2
Micro Edition) com suas subdivisões caracterizados por “Configurações” e “Prefis”,
como descritos a seguir.
28
2. J2ME – JAVA 2 MICRO EDITION
J2ME ou Java 2 Micro Edition é uma tecnologia que possibilita o
desenvolvimento de software para sistemas e aplicações embarcadas, ou seja, para
as aplicações que rodam em dispositivos portáteis, como por exemplo, os PDAs,
telefones celulares e controles remotos, pois eles possuem recursos e funções
limitadas. Java ME é uma coleção de APIs do Java definidas através da Java
Community Proccess (JCP).
Em [7], MUCHOW afirma que J2ME é um pacote padrão de utilidades para
desenvolvimento de aplicações para dispositivos móveis, na qual permite o uso dos
perfis Mobile Information Device Profile (MIDP) 1.0, 2.0, 2.1 nas configurações
Connected Limited Device Configuration (CLDC) e Connected Device Configuration
(CDC).
As aplicações que são executadas nesses dispositivos têm funcionamento
diferenciado das aplicações desenvolvidas para servidores ou desktop. A interação
do usuário com o dispositivo pode ocorrer a qualquer hora do dia, em qualquer lugar,
pois o usuário terá em mãos o dispositivo e o mesmo pode precisar integrar com
algum tipo de serviço, desde que para isto se tenha disponível cobertura de rede
sem fio, seja ela por wireless ou até mesmo serviços de navegação oferecidos por
operadoras de celular.
2.1.
Arquitetura do J2ME
A arquitetura do J2ME é dividida em quatro camadas, sendo elas Perfis,
Configurações, Máquinas Virtuais e Sistema Operacional [8], de acordo com a
Figura 4.
29
Figura 4 - Arquitetura J2ME
Na primeira das camadas temos o sistema operacional hospedeiro, que é o
SO instalado no dispositivo móvel, como o Symbian, enfoque principal deste
trabalho.
Na segunda camada temos a máquina virtual, conhecida como Kilobyte
Virtual Machine (KVM), que é uma máquina virtual desenvolvida para a família de
dispositivos telefônicos e celulares, especialmente implementada para executar
programas em dispositivos com pouca capacidade computacional (i.e. memória e
processador limitados).
Na terceira camada são definidas as configurações, que são conjuntos de
classes, bibliotecas e APIs que definem os recursos necessários para o
funcionamento da máquina virtual, bem como as funcionalidades básicas para cada
categoria de dispositivos.
Na última camada são delimitados os perfis, que são conjuntos de
aplicações
cuja
finalidade
é
complementar
uma
configuração
e
fornecer
funcionalidades adicionais para desenvolver um aplicativo para um determinado
dispositivo.
É possível inserir no topo das camadas o item “APIs opcionais”. Estas APIs
são utilizadas em conjunto com as configurações e perfis para estender as
funcionalidades não encontradas nestes, como por exemplo, utilização de Bluetooth,
Wireless e Web Services (WS).
30
A seguir serão abordados os conceitos de Configurações, Perfis e Máquinas
Virtuais.
2.2.
Configurações
O conceito de configuração foi criado para dividir em espécie de categorias a
ampla variedade de dispositivos móveis disponíveis para os usuários. O objetivo de
uma configuração é definir um padrão de ambiente de execução de programas de
acordo com suas características de hardware. Cada configuração consiste em uma
JVM com uma coleção de classes Java.
Em [7], MUCHOW mostra que:
Uma configuração define uma plataforma Java para uma ampla
variedade de dispositivos. Ela está intimamente vinculada a uma
máquina virtual Java (JVM, Java Virtual Machine). Na verdade, uma
configuração define os recursos da linguagem Java e as bibliotecas
Java básicas da JVM para esta configuração em particular.
As configurações são divididas basicamente pelos recursos de hardware
disponíveis nos dispositivos móveis, como a quantidade de memória, o poder de
processamento, a capacidade de vídeo e a conectividade de rede, entre outras.
A arquitetura J2ME apresenta atualmente dois tipos de configurações, como
descritos a seguir:
2.2.1. Connected Limited Device Configuration (CLDC)
Sendo 1.1 sua versão atual, a CLDC, ou, Configuração de Dispositivo
Conectado Limitado, abrange dispositivos com grandes restrições referentes à
memória, processamento, capacidade gráfica, tamanho da tela, conexões de rede e
duração da bateria. Fazem parte desta configuração basicamente telefones
celulares, smartphones, PDAs e pagers. Esta configuração será utilizada no decorrer
deste trabalho.
31
Os recursos de hardware são apresentados conforme [8]:
•
Processador de 16-Bit ou 32-Bit com velocidade de 16 MHz ou superior;
•
Memória não-volátil de 160 KB;
•
Memória RAM de 192 KB para a plataforma Java;
•
Possibilidade de conexão com redes sem fio.
O mesmo autor apresenta as quatro classes disponíveis nesta configuração:
java.io - Tratamento de entrada e saída de dados;
java.lang - Classes básicas da linguagem Java.
java.util - Classes de utilidades genéricas (estrutura e manipulação de dados).
java.microedition.io - Exclusivo do J2ME, incluindo as classes de conexão.
A CLDC disponibiliza também alguns pacotes adicionais que podem ser
utilizados em alguns dispositivos para dar suporte a outras funções, como por
exemplo, a execução de conteúdo multimídia (i.e. músicas, imagens, vídeos).
A máquina virtual compatível com a CLDC é a K Virtual Machine (KVM), ou
ainda, Máquina Virtual K. A KVM é uma versão limitada da Java Virtual Machine
(JVM).
MUCHOW [7] explica que:
A KVM foi projetada para ser a menor e a mais eficiente possível, e ainda
permanecer rápida para as necessidades da linguagem Java. Com a
memória sendo normalmente um recurso precioso em dispositivos pequenos
de recursos restritos, a base de tempo de execução é de apenas 60 kilobytes
(aproximadamente). O que explica a origem do K no nome KVM, pois a
máquina virtual executará em apenas algumas dezenas de kilobytes de
memória.
2.2.2.
Connected Device Configuration (CDC)
A segunda configuração é a CDC, ou ainda, Configuração de Dispositivo
Conectado, cuja versão atual é a 1.1.2, abrange dispositivos com mais capacidade
de hardware do que os disponíveis na configuração CLDC (i.e. Televisores do tipo
Set-Top Box, navegadores veiculares e PDAs topo de linha).
32
Hardware básico [8]:
Processador de 32-Bit;
Memória não-volátil de 2.5 MB;
Memória RAM de 2 MB ou superior.
Por não haver tanta limitação de hardware, a máquina virtual que a CDC
utiliza é a máquina virtual tradicional do Java 2 Standart Edition, a qual permite a
utilização de todos os recursos da linguagem Java. Esta configuração também
permite a utilização de pacotes opcionais, sendo eles o suporte a Remote Method
Invocation (RMI), Java Database Connectivity (JDBC), Swing e Java 2D.
Mesmo a divisão destas duas configurações parecendo ser bem definidas, a
evolução dos dispositivos e a melhoria de seus recursos ocasionam uma
sobreposição, dificultando sua classificação. Neste sentido, a Sun introduziu o
conceito de perfil, como descrito a seguir.
2.3.
Perfis
MUCHOW [7] define um perfil como “uma extensão de uma configuração.
Ele fornece as bibliotecas para um desenvolvedor escrever aplicativos para um tipo
particular de dispositivo”.
Um perfil especifica vários tipos de serviços e funcionalidades de alto nível,
como o ciclo de vida da aplicação, elementos de interface gráfica, persistência de
dados e meios de comunicação.
Um perfil é implementado no topo de uma configuração, sendo assim,
intimamente ligado a esta, porém compreende bibliotecas mais
específicas que as disponibilizadas pelas configurações, ou seja, o
perfil complementa a configuração adicionando classes que fornecem
características apropriadas para um tipo particular de dispositivos. [9].
33
Os perfis são divididos entre as configurações da seguinte forma:
Configuração CDC possui os seguintes perfis: Foundation Profile (FP); Personal
Basis Profile (PBP); Personal Profile (PP) e a configuração CLDC possui o perfil
Mobile Information Device Profile (MIDP).
2.3.1.
Foundation Profile (FP)
FP é um perfil básico da configuração CDC, o qual possui um conjunto de
APIs Java para dispositivos que não possuem interface gráfica, ou seja, para
dispositivos de hardware embutido. [10]
Requisitos Mínimos:
2.3.2.
•
512 KB de memória RAM;
•
1 MB de memória ROM;
•
Conectividade com algum tipo de rede.
Personal Basis Profile (PBP)
O PBP também é um perfil da configuração CDC, sendo mais completo que
o FP, suportando dispositivos que tenham interface gráfica. Destina-se a ser usado
em dispositivos que possuem uma capacidade de interface de usuário simples e,
portanto, não permite que mais de uma janela esteja ativa simultaneamente em
outra janela. Apresenta basicamente os mesmo requisitos do FP. [11]
2.3.3.
Personal Profile (PP)
É o perfil mais completo e utilizado da configuração CDC. Inclui todas as
funcionalidades dos perfis FP e PBP com suporte a applets e Abstract Window
Toolkit (AWT, API padrão para interface gráfica do usuário). [12]
34
Requisitos Mínimos:
• 1 MB de memória RAM;
• 2,5 MB de memória ROM;
• Conectividade mais robusta com algum tipo de rede;
• Interface gráfica do usuário (GUI).
2.3.4.
Mobile Information Device Profile (MIDP)
O perfil MIDP é o único perfil compatível com CLDC e implementa
componentes, entrada e tratamento de eventos de interface com usuário,
armazenamento persistente, interligação em rede, segurança, entre outros recursos.
Sua última versão é a 2.1 e, por ser um perfil pertencente à configuração mais
simples, contempla apenas os dispositivos com hardware mais limitado (i.e.
telefones celulares, smartphones), objetos em estudo neste trabalho.
Requisitos mínimos:
• 512 KB de memória ROM + RAM para bibliotecas e Java;
• Conectividade com algum tipo de rede;
• Interface gráfica com recursos variados entre os dispositivos.
JOHNSON [8] salienta que:
O MIDP apresenta diversas funcionalidades, como suporte aos
protocolos de rede do tipo HTTP e sockets, reprodução de multimídia,
definição de formulários e itens, APIs para jogos, suporte ao sistema
de cores RGB e validação de permissões de segurança e assinaturas
virtuais.
A seguir, a Tabela 2 apresenta a comparação dos quatro perfis descritos
anteriormente.
35
Perfil
Configuração
Última
Versão
Processador ROM
RAM
Foundation
Profile
CDC
1.1.2
32 bits
> 1MB
> 512 KB • Rede
Hardware
Embutido
> 1MB
• Rede
> 512 KB • Interface
Gráfica
Hardware
Embutido com
Interface
Gráfica
Personal
Basis Profile
CDC
1.1
32 bits
Outros
Personal
Profile
CDC
1.1
32 bits
> 2,5 MB > 1 MB
• Rede Robusta
• Interface
Gráfica AWT
Mobile
Information
Device
Profile
CLDC
2.1
> 16MHz
16 ou 32
bits
> 512 KB
• Rede
• Interface
Gráfica
Dispositivos
Hardware
Embutido com
Interface
Gráfica AWT
• Celulares
• Smartphones
Tabela 2 - Comparação entre perfis das configurações CDC e CLDC
Fonte: Do autor.
Após analisar as configurações e perfis existentes na classificação dos
dispositivos, definimos o perfil a ser utilizado no escopo principal deste trabalho, que
é desenvolver aplicações para telefones celulares. Portanto, define-se como
configuração a CLDC e como perfil, o MIDP, detalhado a seguir, no Capítulo 3.
Este capítulo apresentou a linguagem J2ME e suas particularidades. O
Capítulo 3, a seguir, descreve detalhadamente o perfil MIDP (Mobile Information
Device Profile), apresentando os MIDlets, que são as aplicações desenvolvidas.
36
3. MOBILE INFORMATION DEVICE PROFILE - MIDP
Neste capítulo, serão apresentadas algumas características do Perfil de
Dispositivo de Informação Móvel (MIDP), ou simplesmente Perfil MID.
Dando continuidade ao conteúdo exposto no Capítulo 2.3.4, será mostrado a
API microedition, os MIDlets e a interface gráfica.
3.1. API microedition
A API microedition é o conjunto de pacotes para utilização somente em um
perfil MIDP. JOHNSON [8] apresenta os cinco pacotes que compõem a API,
conforme Tabela 3.
Pacote
Definição
javax.microedition.midlet.*
Define as aplicações MIDP e a interação entre a aplicação e o
ambiente de execução.
javax.microedition.lcdui.*
Fornece as classes para implementação da interface gráfica.
javax.microedition.lcdui.game.*
Fornece as classes para desenvolvimento de Jogos.
javax.microedition.rms.*
Fornece as classes usadas para implementar armazenamento de
dados no dispositivo.
javax.microedition.pki.*
Permite uso de autenticação para comunicações seguras.
Tabela 3 - Pacotes da API microedition.
37
Como o perfil MIDP faz parte da configuração CLDC, os pacotes disponíveis
para esta configuração também ficam disponíveis para o perfil. A Tabela 4 apresenta
estes pacotes adicionais [8].
Pacote
java.lang
java.io
java.util
javax.microedition.io
Definição
Classes fundamentais da linguagem Java
Classes de entrada e saída, arquivos
Utilidades, Data, Hora, entre outros
Conexões de rede
Tabela 4 - Pacotes adicionais do CLDC.
3.2.
MIDlets
Todos os dispositivos móveis possuem um Application Manager Software
(AMS) cuja finalidade é controlar os aplicativos a serem instalados, definindo onde,
quando e como serão armazenados e executados. A comunicação do gerenciador
com
o
MIDlet
acontece
através
da
classe
MIDlet
presente
no
pacote
javax.microedition.midlet.MIDlet. Esta classe é herdada pelos MIDlets para que os
métodos de inicialização, pausa, resumo e interrupção da execução destes possam
ser realizados.
MUCHOW [7] define uma MIDlet como:
Um aplicativo Java projetado para ser executado em um dispositivo
móvel. Mais especificamente, uma MIDlet tem como classe Java
básicas a CLDC e o MIDP. Um conjunto de MIDlets consiste em uma
ou mais MIDlets empacotadas usando um arquivo Java Archive
(JAR).
3.2.1. Ciclo de vida de um MIDlet
O ciclo de vida de uma aplicação desenvolvida em J2ME é gerenciado pela
classe MIDlet. VINAGRE e VIANA [13] descrevem que um MIDlet pode assumir um
dos três estados: ativo, pausado e destruído, conforme Figura 5.
38
Figura 5 - Ciclo de vida de um MIDlet
Ativo: Quando o MIDlet está em execução;
Pausado: Coloca o MIDlet em estado de pausa, disponibilizando os
recursos do celular para outras atividades.
Destruído: Quando a MIDlet encerrou suas atividades e liberou todos os
recursos utilizados por este.
A classe MIDlet provê três métodos abstratos que são obrigatoriamente
utilizados pela aplicação. São eles: startApp(), pauseApp() e destroyApp() [13].
startApp() - Chamado depois do construtor. Mudar o estado de inativo para
ativo, tornando o aplicativo “visível”. Como este método é chamado toda vez que a
aplicação inicia ou volta do estado pausado, é recomendável evitar colocar códigos
de inicialização que só possa ser rodado uma única vez.
pauseApp() – Informa ao aplicativo que este será pausado, ou seja, deixará
de ser executado, geralmente para dar lugar a outra aplicação (i.e. chamada
recebida pelo celular), uma vez que a maioria dos dispositivos móveis não suporta
várias aplicações executando simultaneamente.
39
destroyApp() – Este método é chamado quando a aplicação estiver prestes
a ser encerrada e só pode ser executado apenas uma vez. Deve-se implementar
neste método uma forma de efetuar uma “limpeza” nos objetos criados pela
aplicação, uma vez que o MIDP não possui esta capacidade.
Resumidamente, uma aplicação inicia quando o AMS executa o método
startApp(), passando o aplicativo do estado inativo para o estado ativo. Neste estado
o usuário utiliza a aplicação normalmente. Caso ocorra uma ligação telefônica, por
exemplo, o AMS pode executar o método pauseApp() e passar o aplicativo do
estado ativo para o estado pausado. Ao finalizar a ligação, o AMS executa o método
startApp() novamente e o aplicativo passa para o estado ativo novamente. Quando o
usuário deseja encerrar o aplicativo, o AMS executa o método destroyApp() para
que sejam liberados os recursos utilizados por este, e para que o telefone celular
possa assumir outras aplicações.
MUCHOW [7] afirma que estes três métodos descritos anteriormente são
utilizados, no sentido, do gerenciador de aplicativos AMS para o MIDlet. Existem
também outros três métodos que partem do MIDlet para o gerenciador AMS. São
eles:
notifyDestroy(): Avisa ao gerenciador que pode desligar a MIDlet.
notifyPaused(): Envia o pedido de pausa para o gerenciador caso a MIDlet
necessite de uma pausa.
resumeRequest(): Avisa ao gerenciador que a MIDlet pode tornar-se ativa
novamente.
40
3.3.
Midlets Suite
Uma MIDlet Suite é o nome dado para a coleção de arquivos e recursos que
fazem parte do MIDlet [8]. Esta coleção de arquivos consiste em classes Java
empacotadas em um arquivo JAR, juntamente com um arquivo de manifesto, os
recursos (i.e. imagens, sons) e um arquivo que descreve a aplicação (descritor), ou
seja, o Java Application Descriptor (JAD).
Arquivo de Manifesto – É um arquivo com extensão .mf, o qual descreve o
conteúdo do pacote JAR e é armazenado dentro do próprio JAR. Possui as
seguintes informações: nome do pacote, versão, nome, nome do criador, ícone,
nome da classe principal, perfil e configuração utilizados pelo MIDlet, além de outras
informações opcionais, como descrição e tamanho do MIDlet [8].
Arquivo Descritor – O arquivo descritor, ou arquivo JAD possui muitas
informações repetidas do arquivo de manifesto, porém eles ficam fora do pacote
JAR. Por este motivo, estas informações podem ser acessadas pelo AMS sem que o
MIDlet esteja instalado. Caso haja informações diferentes entre o arquivo JAD e o
arquivo de manifesto, os atributos do arquivo JAD prevalecem. [8]
41
4. INTERFACE GRÁFICA DE UM MIDLET
Ao criar aplicativos para o perfil MIDP, o programador encontra grandes
problemas quanto à interface gráfica. Geralmente dotados de telas pequenas e com
baixa resolução, os dispositivos com configuração CLDC não implementam alguns
componentes de uso comum em aplicativos Java que rodam em computadores
comuns.
A Figura 6, a seguir, mostra a hierarquia de classes da interface gráfica do
MIDP [7]. Na sequência, uma breve descrição de cada uma delas com suas
respectivas subclasses, disponibilizadas por [7] e [8].
Figura 6 - Hierarquia de Classes de interface gráfica do MIDP.
A biblioteca que define os componentes visuais que podem ser utilizados na
elaboração das telas dos MIDlets é a javax.microedition.lcdui.*. Os objetos
disponíveis são descritos a seguir.
42
Os métodos para manipulação dos objetos e das classes dos componentes
visuais podem ser consultados na documentação do J2ME, disponível em [15].
Exemplos de utilização e formas de implementação (códigos fontes) serão descritos
no capítulo sobre desenvolvimento (Capítulo 5.5.5).
4.1.
Display
O objeto Display é o gerenciador da tela de exibição do dispositivo. É ele
quem controla o que e quando será exibido na tela. Existe apenas um objeto Display
para cada MIDlet, porém neste objeto Display podem ser exibidos diversos objetos,
a partir do objeto Displayable.
4.2.
Displayable – Interface com o usuário de alto nível
Os objetos do Displayable são os componentes que podem ser vistos na tela
do celular, ou seja, no objeto Display. O MIDP inclui duas subclasses do
Displayable. São elas a Screen e o Canvas. A subclasse Screen utiliza componentes
de alto nível enquanto a subclasse Canvas é de baixo nível.
4.3.
Command
A classe Command permite que o usuário interaja com a aplicação. Ela
permite adicionar funções relacionadas aos objetos que estão sendo exibidos na
tela.
43
Os tipos de comandos podem ser:
Tipo
Back
Cancel
Exit
Help
Item
Descrição
Comando voltar à tela anterior
Cancelar alguma ação na tela atual
Comando para sair da aplicação
Chama a ajuda do aplicativo*
Comando específico de um Item na tela
* A ajuda deve ser implementada pelo desenvolvedor.
Tabela 5 - Tipos de Command
4.4.
Ticker
Um Ticker nada mais é do que uma mensagem que fica “deslizando”
horizontalmente da direita para esquerda no topo da tela de um MIDlet. Ao terminar
de exibir a mensagem, esta reinicia sua exibição automaticamente. O Ticker
funciona apenas quando o MIDlet implementa a classe Screen.
4.5.
Screen
A classe Screen não é uma classe que pode ser “visualizada”, porém ela
possui objetos que são visíveis em qualquer um dos quatro tipos de tela (TextBox,
List, Alert, Form), como a seguir.
4.5.1. TextBox
TextBox, ou ainda Caixa de Texto, é uma área de várias linhas onde o
usuário pode utilizar como entrada de texto. Permite filtrar o texto digitado como:
qualquer texto; endereço de e-mail; numérico; senha (exibe apenas asteriscos);
número de telefone e endereços de URL.
44
4.5.2. List
List é um tipo de tela que apresenta ao usuário uma lista com itens
selecionáveis através do botão de seleção do celular. Ocupa toda a tela do celular e
oferece três tipos de interface.
Exclusive: exibe uma lista que permite a seleção de apenas um único item.
Multiple: exibe uma lista que permite a seleção de mais de um item.
Implicit: cada item da lista está associado a um comando que pode
executar uma determinada função.
4.5.3. Alert
Um Alert é uma caixa de diálogo que pode conter um texto e uma imagem.
Geralmente aparecem apenas por um período de tempo (timeout) antes de exibir
outro componente Displayable. O Alert pode assumir um dos cinco tipos:
Alarm: Aviso sobre algum evento requisitado pelo usuário. Ex: Nota de
calendário.
Confirmation: Mostra uma mensagem de confirmação.
Error: Exibe uma mensagem de erro.
Info: Fornece algum tipo de informação ao usuário.
Warning: Exibe uma mensagem para alertar o usuário sobre algum perigo
ou aviso.
4.5.4. Form
Form é a tela mais utilizada nos MIDlets. Ela pode conter diversos tipos de
itens, como imagens, textos, campos editáveis, entre outros, além de conter
Commands para interação com o usuário. Um objeto Form tem métodos para
anexar, inserir, substituir e excluir componentes (Itens). Componentes estes que são
descritos na sequência.
45
4.5.5. Item
Um Item é a superclasse dos elementos que podem ser adicionados em um
objeto Form.
MUCHOW [7] salienta que:
A classe ItemStateListener trabalha junto com um objeto Item.
Quando se quer processar eventos em um objeto Item, basta registrar
um “receptor” que receberá uma mensagem, quando um evento
ocorrer. O destinatário dessa mensagem é o método
itemStateChanged(). Com esse método, você pode determinar qual
objeto Item mudou e decidir qual ação gostaria de executar.
A Figura 6 - Hierarquia de Classes de interface gráfica do MIDP., mostrada no
início deste capítulo, ilustra o componente Item como uma subclasse do Form, o que
não ocorre realmente. Esta ilustração é feita apenas para mostrar que um Form
aceita diversos “Items”. A seguir, descrição de cada componente que compõe o
Item.
4.5.5.1.
ChoiceGroup
Um ChoiceGroup possui as mesmas características de funcionamento de um
List (Capítulo 4.5.2). A principal diferença é que um Item ChoiceGroup não ocupa
toda a tela do dispositivo, salvo casos em que há um grande número de itens na
lista, ou seja, permite que outros objetos Item sejam adicionados em um mesmo
Form. Outra diferença importante é que o ChoiceGroup não implementa o tipo
Implicit presente em um List.
4.5.5.2.
DateField
O componente DateField é usado para mostrar a data e a hora na tela do
dispositivo. Muitas vezes é necessário usar as classes Date (java.util.Date) e
Calendar (java.util.Calendar) para que seja possível exibir a data e a hora atual.
Permite a exibição de apenas a data, apenas a hora, ou os dois simultaneamente.
46
4.5.5.3.
TextField
Um TextField é um campo que permite a inserção de caracteres/palavras em
um Form. Possui diversos tipos de restrições de entrada que podem ser
“configurados”, como por exemplo, campos que só permitem dados numéricos,
alfanuméricos, números decimais, endereços de e-mail e URL, senhas, entre outros,
forçando ao usuário a digitar apenas o tipo de conteúdo pré-definido.
4.5.5.4.
Gauge
Um componente Gauge é similar a uma barra de progresso presente em
vários tipos de aplicações na computação para desktop. Possui duas maneiras de
ser atualizado. A primeira delas é pelo modo interativo onde é o usuário que faz a
alteração, e a segunda é pelo modo não-interativo, sendo atualizado através da
programação. Exemplos práticos seriam o ajuste de volume do dispositivo no
primeiro modo e, uma barra como progresso do download de um arquivo no
segundo modo.
4.5.5.5.
ImageItem
O objeto ImageItem permite que sejam inseridas uma ou mais imagens na
tela do dispositivo a partir de um objeto Image. Este objeto Image pode estar
armazenado no pacote da aplicação, ou pode ser baixado da internet.
4.5.5.6.
StringItem
StringItem é um objeto cuja finalidade é inserir um Item que contenha uma
String. Este objeto apenas insere a palavra ou texto, ou seja, não permite que o
usuário possa editá-lo, como ocorre com o TextField. Somente é possível alterar seu
conteúdo através da programação do MIDlet.
47
4.6.
Canvas – Interface com o usuário de baixo nível
Canvas é uma subclasse de Displayable que permite a implementação de
gráficos e eventos. É uma classe de baixo nível e destina-se a aplicações que
necessitem de um posicionamento mais preciso dos elementos, sendo utilizada
principalmente para a criação de jogos. Também fornece métodos para tratamento
de eventos de baixo nível e utiliza objetos Graphic para desenhar na tela.
4.6.1. Graphics
Os objetos Graphics são utilizados para formar desenhos na tela. Possuem
métodos para desenhar arcos, retângulos, linhas, imagens e texto, juntamente com
métodos que permitem manipular cores em RGB (Red, Green, Blue). Estes objetos
podem ser alinhados/posicionados de acordo com coordenadas X e Y que
representam os pixels na tela.
Este capítulo apresentou os recursos disponíveis na tecnologia J2ME para o
desenvolvimento de MIDlets do perfil MIDP. No Capítulo 5 serão abordadas as
ferramentas necessárias para o desenvolvimento destas MIDlets, bem como
instruções básicas para sua programação.
48
5. AMBIENTE DE DESENVOLVIMENTO
5.1.
JDK - Java Development Kit
O JDK é um kit de desenvolvimento Java fornecido gratuitamente pela Sun
Microsystems. É formado por um conjunto de programas que engloba compilador,
interpretador e utilitários, os quais fazem parte de um pacote de ferramentas básicas
para o desenvolvimento de aplicações Java.
Este kit provê uma plataforma Java na qual o Sun Java Wireless Toolkit será
executado. É um software obrigatório para qualquer tipo de desenvolvimento que
envolva Java.
5.1.1.
Baixando e instalando o JDK
O pacote de instalação pode ser adquirido no site da fabricante, a Sun
Microsystems,
no
seguinte
http://www.oracle.com/technetwork/java/javase/downloads/index.html.
endereço:
A
última
versão disponível é a versão 6 update 22, no caso da plataforma Windows 64 bits.
Selecionar a opção “Java Platform (JDK)”, como na Figura 7.
49
Figura 7 - Seleção da JDK para download.
Na página seguinte, selecionar a versão do sistema operacional e o idioma e
clicar em “Continue” (Figura 8).
Figura 8 - Seleção de plataforma e idioma do JDK.
A seguir, será exibido o link para o download do JDK (Figura 9).
Figura 9 - Link para download do JDK.
A instalação do JDK, na plataforma Windows, segue o mesmo padrão de
qualquer outra aplicação comum. Para continuar, basta executar o arquivo baixado
anteriormente e seguir as instruções na tela.
50
5.1.2. Configurando as variáveis de ambiente
Ao seguir a instalação padrão, o JDK será instalado no diretório “C:\Program
Files\Java\jdk1.6.0_22”. Neste momento é necessário adicionar o diretório “bin” do
JDK à variável “path” nas variáveis de ambiente do sistema. No Windows 7, acessar
Painel de controleSistemaConfigurações avançadas do sistemaVariáveis de
ambiente, localizar a variável “path” e adicionar o endereço da JDK (Figura 10).
Figura 10 - Variáveis de ambiente do Windows.
Para testar se tudo foi instalado corretamente, abrir o prompt de comando do
Windows e digitar o comando “java -version” sem as aspas (Figura 11). Deverá
aparecer a versão do Java instalado no computador.
Figura 11 - Verificando a instalação do Java.
51
5.2. IDE Netbeans 6.9.1
É um programa de computador da Sun sob licença free e possui uma
Interface Gráfica com o Usuário (GUI) para desenvolvimento de softwares. As suas
ferramentas de desenvolvimento são integradas com as mais recentes tecnologias
profissionais para a criação e manutenção de grandes projetos na linguagem Java.
O Netbeans é um ambiente integrado de desenvolvimento (IDE) que permite
ao programador criar programas utilizando recursos gráficos. Para trabalhar com o
NetBeans é necessário ter instalado, anteriormente em sua máquina uma das
versões do JDK [15].
É um ambiente de desenvolvimento multiplataforma, uma ferramenta que
auxilia programadores a escrever, compilar, debugar e instalar aplicações. Foi
arquitetada
em
forma
de
uma
estrutura
reutilizável
para
simplificar
o
desenvolvimento e aumentar a produtividade, pois reúne em uma única aplicação
todas estas funcionalidades. [16]
É completamente escrita em Java, porém suporta, outras linguagens de
programação, tais elas como o C, C++, Ruby, PHP, XML e HTML. Como ele é
multiplataforma, ele funciona em qualquer sistema operacional, desde que o mesmo
possua suporte à Máquina Virtual Java (JVM).
5.2.1.
Download e instalação do Netbeans 6.9.1
O download do Netbeans pode ser feito através do seguinte endereço:
http://netbeans.org/downloads/index.html.
Para
desenvolver
aplicações
para
dispositivos móveis utilizando o perfil MIDP é necessário que o Netbeans possua o
pacote “Java ME”. A Figura 12 mostra todas as opções de download. Deve-se
escolher a versão “Java” ou a versão “Tudo”, devido à presença deste pacote.
52
Figura 12 - Versões do Netbeans.
Após baixar o arquivo de instalação, executar e seguir os passos na tela em
uma instalação padrão. Durante a instalação, será exibida a Figura 13. Nesta tela,
geralmente aparecerá automaticamente o endereço da JDK instalada anteriormente.
Caso isto não aconteça, é provável que haja problemas na instalação do JDK.
Poderá ser feita a localização do JDK manualmente, através dos botões “Procurar”.
Figura 13 - Localização do JDK durante a instalação do Netbeans.
53
Após a instalação, o Netbeans está pronto para ser utilizado. A figura a
seguir mostra a interface principal do Netbeans.
Figura 14 - Tela principal do Netbeans 6.9.1.
5.2.2. Wireless Toolkit
O Wireless ToolKit (WTK) é uma ferramenta fornecida pela Sun
Microsystems para o desenvolvimento de aplicativos para celulares. Ele dispõe de
um compilador e um emulador do aparelho celular, onde é possível configurar a
velocidade da CPU do aparelho e o fluxo de rede, para que a emulação seja a mais
próxima possível do real, já que computadores possuem muito mais memória e CPU
e nem sempre o desenvolvedor dispõe do aparelho celular para instalar e testar o
aplicativo. Este kit acompanha o Netbeans e não tem a necessidade de ser instalado
separadamente.
54
5.2.3.
Por que utilizar o Netbeans?
O Netbeans não é a única IDE para desenvolvimento de aplicativos em
J2ME. Existem diversas outras, como por exemplo, o Eclipse, EclipseME, GEL, entre
outros.
A IDE Eclipse também é muito robusta frente à programação para J2ME. O
diferencial de ter utilizado o Netbeans neste projeto é que ele já contém todos os
pacotes para programação e ainda contém o WTK, indispensável para testes de
aplicações.
Utilizando o Netbeans, o usuário não necessitará instalar pacotes adicionais
e plugins, tampouco precisará criar manualmente os arquivos necessários para
executar a aplicação diretamente no celular, pois este apresenta ferramentas que
fazem este papel de forma automatizada.
5.3. Criando um novo projeto no Netbeans 6.9.1
Com o Netbeans aberto, acessar o menu ArquivoNovo projeto.
Figura 15 - Novo projeto no Netbeans.
Selecionar a categoria “Java ME” e em projetos, selecionar “Aplicativo
móvel”. Clicar em próximo.
55
Figura 16 - Seleção do tipo de projeto no Netbeans.
Na tela seguinte, preencha com o nome do projeto e o local onde este
projeto será armazenado. A Opção “Configurar como projeto principal” irá apenas
manter este novo projeto como se fosse o projeto padrão do Netbeans (dos projetos
que estiverem abertos). A vantagem é que ao utilizar os botões de atalho (i.e.
compilação, execução), suas respectivas funções terão efeito neste projeto “padrão”.
A Opção “Criar MIDlet Olá” insere automaticamente uma MIDlet com sua
estrutura básica de funcionamento. Optar por desmarcar esta opção evita que sejam
inseridos códigos inúteis no MIDlet.
56
Figura 17 - Propriedades da nova aplicação no Netbeans.
Após as informações iniciais da aplicação, seleciona-se a plataforma do
emulador. Como há apenas a plataforma Wireless Toolkit, apenas esta opção estará
disponível. Selecionar também “CLDC-1.1” e “MIDP-2.1” para obter o máximo de
recursos disponíveis para a configuração CLDC no perfil MIDP. Em alguns casos
será necessário selecionar a opção MIDP 2.0, pois alguns telefones celulares não
suportam o MIDP-2.1.
57
Figura 18 - Seleção da Plataforma no Netbeans.
Na última tela antes de finalizar a criação do projeto, existem opções para
mais configurações sobre o projeto. Neste caso não há necessidade de alterar
nenhuma opção. Clicar em Finalizar para continuar.
Figura 19 - Configurações finais do projeto.
58
Após criar o protejo, o mesmo pode ser visualizado na coluna à esquerda do
Netbeans.
Figura 20 - Exibição do projeto criado no Netbeans.
Para criar o primeiro MIDlet, ou seja, a primeira “tela” do aplicativo, clicar
com o botão direito em “pacote padrão”, apontar para o menu “Novo” e clicar na
opção “MIDlet”. Preencher os campos com o Nome do MIDlet. O nome da classe é
preenchida automaticamente.
59
Figura 21 - Criação de um MIDlet no projeto do Netbeans.
O Netbeans passa a exibir o código fonte do novo MIDlet criado. Neste
código fonte está presente a estrutura mínima de funcionamento do MIDlet, com os
três principais métodos descritos no Capítulo 3.2.1.
Figura 22 - MIDlet criado no projeto.
60
Para iniciar a programação, segue o código de exemplo criado no novo
MIDlet, alguns elementos, e os comentários explicativos.
//importa a classe midlet
import javax.microedition.midlet.*;
//importa a classe lcdui
import javax.microedition.lcdui.*;
/**
* @author Fabio
*/
//Classe principal do MIDlet estendida de MIDlet e
//implementando CommandListener (para executar comandos)
public class PrimeiraMIDlet extends MIDlet implements CommandListener {
//Cria um objeto do tipo Form
private Form meuFormulario;
//Cria um comando (neste caso, para sair do aplicativo)
private Command sairCommand;
//Construtor criado para executar as funções apenas uma vez
//durante a primeira execução do MIDlet.
public PrimeiraMIDlet() {
//Instancia o objeto com um novo Form e seu título
meuFormulario = new Form("Título da minha primeira MIDlet");
//Adiciona um texto ao Form
meuFormulario.append("Aqui está meu primeiro texto!");
//Cria um comando, neste caso, o sair
sairCommand = new Command("Sair", Command.EXIT, 0);
//Adiciona o comando ao formulário
meuFormulario.addCommand(sairCommand);
//Adiciona o "monitoramento" de comandos
meuFormulario.setCommandListener(this);
}
//Método executado quando o MIDlet é iniciado pela primeira vez
//ou quando este retorna do estado Pausado.
public void startApp() {
//Captura o Display do celular e adiciona o
//Form criado para exibição.
Display.getDisplay(this).setCurrent(meuFormulario);
}
//Método executado quando o MIDlet vai entrar em estado Pausado.
public void pauseApp() {
}
//Método executado antes de finalizar o MIDlet.
public void destroyApp(boolean unconditional) {
//Avisa o SO que este pode controlar o display novamente
this.notifyDestroyed();
}
//Permite que a aplicação saiba quando um comando foi acionado
public void commandAction(Command c, Displayable d) {
//Compara o comando solicitado e executa a ação programada
if (c == sairCommand) {
destroyApp(true);
}
}
}
Quadro 1 - Código fonte Aplicação de Exemplo
61
5.4.
Executando a aplicação no Wireless Toolkit (WTK)
Após elaborar o primeiro MIDlet, é possível verificar seu comportamento
como se estivesse em um dispositivo real, utilizando o emulador do WTK. O
Netbeans dispõe de ferramentas que auxiliam neste processo de forma
automatizada, transparente ao usuário.
Acessar o menu ExecutarExecutar o projeto principal ou pressionar a tecla
F6. Estas duas opções funcionam somente se o projeto o qual se quer executar está
configurado como projeto principal no Netbeans. Caso contrário, deve-se clicar com
o botão direito no projeto e selecionar no submenu, o item executar.
A Figura 23 mostra o MIDlet sendo executado no emulador do WTK. Podese perceber o título, o texto e o comando “Sair” adicionados ao MIDlet.
Figura 23 - MIDlet sendo executado no emulador do WTK.
62
Vale lembrar que o emulador do WTK simula a execução do MIDlet, e esta
geralmente é diferente de um dispositivo real, pois trata-se de um emulador
genérico. Para que as aplicações sejam o mais parecido com o real, é necessária a
instalação de outra ferramenta, chamada de Software Development Kit (SDK),
conforme disposto a seguir.
5.5.
Software Development Kit (SDK)
Um SDK emula o comportamento dos telefones celulares de um
determinado fabricante com a máxima semelhança possível do dispositivo real, pois
possuem emuladores baseados no mesmo software que são especificados nestes
dispositivos.
Como o foco deste trabalho é criar aplicações para telefones celulares com
SO Symbian da série S60, mais especificadamente o modelo Nokia N81, é
necessário instalar o “S60 3rd Edition SDK for Symbian OS, Feature Pack 2”. Os
passos de para download, instalação e utilização são mostrados a seguir.
5.5.1.
Software S60 3rd Edition FP2 SDK
Para realizar os testes de implementação sem que seja necessário instalar o
aplicativo no celular, é utilizado o software emulador S60 3rd Edition FP2 SDK da
Nokia, disponível de forma gratuita aos desenvolvedores de software.
Este emulador (Figura 24) simula as condições e recursos reais dos
aparelhos celulares da série S60 da Nokia, para que as aplicações sejam testadas e
utilizadas como se estivessem realmente instaladas em um dispositivo real, o que
fornece mais comodidade e confiabilidade ao se programar em J2ME [17].
63
Figura 24 - Emulador da Nokia S60 3rd Edition FP2 SDK
5.5.2.
Download e instalação do SDK S60 3rd Edition, FP2
A Nokia [17] possui o melhor site de suporte ao desenvolvimento de
aplicativos para celular. Disponibiliza todas as ferramentas necessárias para a
programação em seus telefones celulares, bem como uma vasta documentação
sobre cada um deles e ainda, um fórum onde programadores de todo o mundo
podem trocar experiências e auxiliar quem necessita de ajuda durante o
desenvolvimento.
Para
efetuar
o
download
do
SDK,
acessar
a
página
http://www.forum.nokia.com/info/sw.nokia.com/id/ec866fab-4b76-49f6-b5a5-af06314
19e9c/S60_All_in_One_SDKs.html e selecionar a série desejada, conforme Figura
25.
64
Figura 25 - Download do SDK Nokia S60 3rd Edition FP2
Após o download, executar o arquivo. A instalação também segue o padrão
de instalação do Windows. Caso aparecer a mensagem da Figura 26, é necessária a
instalação do ActivePerl, pois o SDK produzido pela Nokia utiliza a linguagem Perl
para ser executada.
Figura 26 - Solicitação de instalação do ActivePerl.
O Download do ActivePerl pode ser feito no site oficial do ActivePerl [18].
Sua instalação também é muito simples, seguindo o padrão do Windows.
Após a instalação é necessário configurar o Netbeans para reconhecer a
nova plataforma.
65
5.5.3.
Adicionando a plataforma S60 ao Netbeans
Para utilizar o SDK, este deve ser reconhecido como plataforma pelo
Netbeans.
Para
efetuar
este
reconhecimento,
deve-se
acessar
o
menu
FerramentasPlataformas Java, na tela principal do Netbeans.
Na Figura 27, clicar em “Adicionar plataforma”.
Figura 27 - Adicionar Plataforma ao Netbeans.
Na tela seguinte, marcar a opção “Emulador de plataforma MIDP Java ME”
(Figura 28).
66
Figura 28 – Tipos de Plataformas no Netbeans.
Na janela de seleção de diretórios do Windows, selecionar o diretório onde
está instalada a plataforma do S60, geralmente em “C:/S60”. Neste ponto o
Netbeans irá procurar e selecionar as plataformas. Clicar em próximo e logo após
em finalizar. O Netbeans já está configurado e pronto para utilizar a nova plataforma.
5.5.4.
Executando a aplicação na Plataforma S60
Existem duas maneiras de executar a pequena aplicação desenvolvida no
Capítulo 5.3. A primeira delas é clicar com o botão direito no projeto e clicar em
“Executar com”. Agora é necessário selecionar a plataforma S60, conforme Figura
29.
Figura 29 - Seleção de plataforma para execução do MIDlet.
67
Será exibido o emulador com o MIDlet sendo executado. É visível a
diferença do MIDlet apresentado neste emulador (Figura 30) em relação ao
emulador do WTK (Figura 23).
Figura 30 - MIDlet sendo executado no emulador do S60.
A posição dos elementos do MIDlet apresentado no emulador do S60 são
semelhantes aos apresentados em um dispositivo real, o Nokia N81 (Figura 31). O
que difere do emulador para o celular são as configurações de “temas” do celular.
Figura 31 - MIDlet sendo executado no celular Nokia N81
68
A segunda maneira de executar esta MIDlet, porém agora de forma
permanente, é configurar o projeto para utilizar apenas determinada plataforma.
Desta forma, toda vez que utilizar os comandos de execução, o MIDlet será
executado na plataforma escolhida.
Para efetuar esta configuração, deve-se clicar com o botão direito no projeto
e selecionar o item propriedades. Na tela exibida (Figura 32 - Configuração de
plataforma no projeto do Netbeans.), Escolher a “Plataforma do emulador” com o
item “S60 3rd Edition FP2 SDK” e em “Dispositivo” selecionar “S60Emulator”.
Figura 32 - Configuração de plataforma no projeto do Netbeans.
Para instalar o aplicativo em um dispositivo real, basta copiar os arquivos
com extensão .JAD e .JAR disponíveis na pasta “dist” dentro do diretório onde se
encontra o projeto do Netbeans. Caso estes arquivos não existam, é necessário
compilar o projeto (menu ExecutarConstruir projeto principal, ou, tecla F11), ou
ainda, executá-lo utilizando um emulador pelo menos uma vez.
69
5.5.5.
Utilizando os elementos visuais de alto nível
Seguindo o mesmo padrão do projeto criado anteriormente, foi criada uma
nova MIDlet para mostrar o comportamento dos elementos visuais de alto nível que
o J2ME fornece para o perfil MIDP, apresentados no Capítulo 4.5.
5.5.5.1. TextBox
O TextBox é o primeiro elemento. Por se tratar de uma nova aplicação, será
mostrado o código completo e sua visualização na tela, utilizando o emulador do
S60. Nos demais elementos, serão mostrados apenas trechos de códigos
comentados com suas respectivas telas. Ao lado de cada imagem, será exibida uma
foto do dispositivo real.
//importa a classe midlet
import javax.microedition.midlet.*;
//importa a classe lcdui
import javax.microedition.lcdui.*;
/**
* @author Fabio
*/
//Classe principal do MIDlet estendida de MIDlet e
//implementando CommandListener (para executar comandos)
public class ExemploTextBox extends MIDlet implements CommandListener {
//Cria um objeto do tipo TextBox
private TextBox meuTextBox;
//Cria um comando (neste caso, para sair do aplicativo)
private Command sairCommand;
//Cria um objeto Display
//private Display display;
//Construtor criado para executar as funções apenas uma vez
//durante a primeira execução do MIDlet.
public ExemploTextBox() {
//Cria o objeto TextBox com os seguintes parâmetros:
//1 - Título do TextBox
//2 - Texto interno, caso necessitar
//3 - Quantidade máxima de caracteres
//4 - Restrições: Qualquer valor, numérico, texto, senha, URL
meuTextBox = new TextBox("Título do TextBox", "", 100,
TextField.ANY);
//Cria o comando para sair da aplicação
sairCommand = new Command("Sair", Command.EXIT, 0);
70
//Adiciona o comando ao formulário
meuTextBox.addCommand(sairCommand);
//Adiciona o "monitoramento" de comandos
meuTextBox.setCommandListener(this);
}
//Método executado quando o MIDlet é iniciado pela primeira vez
//ou quando este retorna do estado Pausado.
public void startApp() {
//Captura o Display do celular e adiciona o
//Form criado para exibição.
Display.getDisplay(this).setCurrent(meuTextBox);
}
//Método executado quando o MIDlet vai entrar em estado Pausado.
public void pauseApp() {
}
//Método executado antes de finalizar o MIDlet.
public void destroyApp(boolean unconditional) {
//Avisa o SO que este pode controlar o display novamente
this.notifyDestroyed();
}
//Permite que a aplicação saiba quando um comando foi acionado
public void commandAction(Command c, Displayable d) {
//Compara o comando solicitado e executa a ação programada
if (c == sairCommand) {
destroyApp(true);
}
}
}
Quadro 2 - Código fonte TextBox
Figura 33 - Exemplo TextBox
71
5.5.5.2. List
//Cria um objeto do tipo List
private List meuList;
public ExemploList() {
//Cria o objeto List com os seguintes parâmetros:
//1 - Título do List
//2 - Restrições: Exclusivo, Múltiplo, Implícito
meuList = new List("Título do List", Choice.EXCLUSIVE);
OU
meuList = new List("Título do List", Choice.MULTIPLE);
OU
meuList = new List("Título do List", Choice.IMPLICIT);
//Cria as opções da lista
meuList.append("Opção 1", null);
meuList.append("Opção 2", null);
meuList.append("Opção 3", null);
meuList.append("Opção 4", null);
meuList.append("Opção 5", null);
meuList.append("Opção 6", null);
}
Quadro 3 - Código fonte List
Figura 34 - Exemplo List Exclusive, Multiple e Implicit
72
5.5.5.3. Alert
//Cria um objeto do tipo TextBox
private Alert meuAlert;
public ExemploAlert() {
//Cria o objeto Alert com os seguintes parâmetros:
//1 - Título do Alert
//2 - Texto ou mensagem do Alert
//3 - Imagem do Alert, caso houver
//4 - Tipo: Confirmação, Erro, Informação, Aviso
meuAlert = new Alert("Título do Alert", "Esta é uma mensagem de
erro!", null, AlertType.ERROR);
//Configura o "tempo de vida" do Alert.
meuAlert.setTimeout(Alert.FOREVER);
}
Quadro 4 - Código fonte Alert
Figura 35 - Exemplo Alert - Erro
5.5.5.4. Form (e seus “Items”)
5.5.5.4.1.
ChoiceGroup
//Cria um objeto do tipo Form
private Form meuFormulario;
//Cria os objetos ChoiceGroup
private ChoiceGroup meuChoiceGroupExclusive;
private ChoiceGroup meuChoiceGroupMultiple;
public ExemploFormChoiceGroup() {
//Instancia o objeto com um novo Form e seu título
meuFormulario = new Form("ChoiceGroup");
//Cria um ChoiceGroup do tipo Exclusivo
meuChoiceGroupExclusive = new ChoiceGroup("ChoiceGroup Exclusivo",
Choice.EXCLUSIVE);
//Insere os itens no ChoiceGroup
meuChoiceGroupExclusive.append("Opção Exclusiva 1", null);
meuChoiceGroupExclusive.append("Opção Exclusiva 2", null);
73
meuChoiceGroupExclusive.append("Opção Exclusiva 3", null);
//Insere o ChoiceGroup no formulário
meuFormulario.append(meuChoiceGroupExclusive);
//Cria um ChoiceGroup do tipo Múltiplo
meuChoiceGroupMultiple = new ChoiceGroup("ChoiceGroup Múltiplo",
Choice.MULTIPLE);
//Insere os itens no ChoiceGroup
meuChoiceGroupMultiple.append("Opção Múltipla 1", null);
meuChoiceGroupMultiple.append("Opção Múltipla 2", null);
meuChoiceGroupMultiple.append("Opção Múltipla 3", null);
//Insere o ChoiceGroup no formulário
meuFormulario.append(meuChoiceGroupMultiple);
}
Quadro 5 - Código fonte ChoiceGroup
Figura 36 - Exemplo ChoiceGroup
5.5.5.4.2.
DateField
//importa a classe para trabalhar com datas
import java.util.Date;
public class ExemploFormDateField extends MIDlet implements CommandListener
{
//Cria um objeto do tipo Form
private Form meuFormulario;
//Cria os objetos DateField
private DateField meuDateFieldDate;
private DateField meuDateFieldTime;
private DateField meuDateFieldDateTime;
//Construtor criado para executar as funções apenas uma vez durante a
//primeira execução do MIDlet.
public ExemploFormDateField() {
//Instancia o objeto com um novo Form e seu título
meuFormulario = new Form("DateField");
//Data atual do sistema (celular)
Date dataAtual = new Date();
74
//Cria um DateField do tipo DATE com os seguintes parâmetros:
//1 - Título do DateField
//2 - Tipo: Data, Hora, Data e Hora
meuDateFieldDate = new DateField("DateField Date", DateField.DATE);
//Insere a data atual
meuDateFieldDate.setDate(dataAtual);
//Insere o DateField no formulário
meuFormulario.append(meuDateFieldDate);
//Cria um DateField do tipo TIME com os seguintes parâmetros:
//1 - Título do DateField
//2 - Tipo: Data, Hora, Data e Hora
meuDateFieldTime = new DateField("DateField Time", DateField.TIME);
//Neste exemplo o próprio usuário digita a hora
//Insere o DateField no formulário
meuFormulario.append(meuDateFieldTime);
//Cria um DateField do tipo DATE_TIME com os seguintes parâmetros:
//1 - Título do DateField
//2 - Tipo: Data, Hora, Data e Hora
meuDateFieldDateTime = new DateField("DateField Date_Time",
DateField.DATE_TIME);
//Insere a data atual
meuDateFieldDateTime.setDate(dataAtual);
//Insere o DateField no formulário
meuFormulario.append(meuDateFieldDateTime);
}
Quadro 6 - Código fonte DateField
Figura 37 - Exemplo DateField
5.5.5.4.3.
TextField
//Cria um objeto do tipo Form
private Form meuFormulario;
public ExemploFormTextField() {
//Instancia o objeto com um novo Form e seu título
meuFormulario = new Form("TextField");
//Cria os objetos TextField com os seguintes parâmetros:
//1 - Label do TextField
//2 - Texto ou mensagem do TextField
75
//3 - Quantidade Máxima de Caracteres
//4 - Restrições: Qualquer, numérico, texto, senha, URL
meuFormulario.append(new TextField("Nome: ", "", 25,
TextField.INITIAL_CAPS_WORD));
meuFormulario.append(new TextField("E-mail: ", "", 25,
TextField.EMAILADDR));
meuFormulario.append(new TextField("Login: ", "", 25, TextField.ANY));
meuFormulario.append(new TextField("Senha: ", "", 25, TextField.PASSWORD));
}
Quadro 7 - Código fonte TextField
Figura 38 - Exemplo TextField.
5.5.5.4.4.
Gauge
public ExemploFormGauge() {
//Instancia o objeto com um novo Form e seu título
meuFormulario = new Form("TextField");
//Cria um Gauge com os seguintes parâmetros:
//1 - Label do Gauge
//2 - Interativo: Sim ou não
//3 - Valor máximo para referência. Ex: 100 (%)
//4 - Valor para exibição. Ex: 75 (%)
//Gauge Interativo
meuFormulario.append(new Gauge("Gauge Interativo", true, 100, 75));
//Gauge Não-interativo
meuFormulario.append(new Gauge("Gauge Não-interativo", false, 100, 35));
}
Quadro 8 - Código fonte Gauge
Figura 39 - Exemplo Gauge.
76
5.5.5.4.5.
ImageItem
private Image imagem;
public ExemploFormImageItem() {
//Instancia o objeto com um novo Form e seu título
meuFormulario = new Form("TextField");
//Utiliza-se a estrutura try, pois caso a imagem não existir
//o MIDlet poderá tratar o erro. Caso contrário, o MIDlet
//poderá travar e deixar o dispositivo sem ação forçando o
//usuário a desligá-lo
Try {
imagem = Image.createImage("selo.png");
} catch (IOException ex) {
ex.printStackTrace();
}
//Insere um ImageItem com os seguintes parâmetros
//1 - Label da Imagem
//2 - Imagem (arquivo.png)
//3 - Layout da imagem: Esquerda, direita, centralizado, default
//4 - Texto alternativo: exibe o texto quando a imagem não
//puder ser exibida (incapacidade do dispositivo)
meuFormulario.append(new ImageItem("Informática", imagem,
ImageItem.LAYOUT_CENTER, "Informática"));
}
Quadro 9 - Código fonte ImageItem
Figura 40 - Exemplo ImageItem.
5.5.5.4.6.
StringItem
public ExemploFormStringItem() {
//Instancia o objeto com um novo Form e seu título
meuFormulario = new Form("StringItem");
//Cria o objeto StringItem com os seguintes parâmetros:
//1 - Label do StringItem
//2 - Texto do StringItem
meuFormulario.append(new StringItem("Nome: ", "Luis Fabio Faccin"));
meuFormulario.append(new StringItem("E-mail: ",
"[email protected]"));
77
meuFormulario.append(new StringItem("Curso: ", "Informática"));
meuFormulario.append(new StringItem("Ano: ", "2010"));
}
Figura 41 - Exemplo StringItem
5.5.6. Exemplo de aplicação: Somar dois números
//importa a classe midlet
import javax.microedition.midlet.*;
//importa a classe lcdui
import javax.microedition.lcdui.*;
/**
* @author Fabio
*/
//Classe principal do MIDlet estendida de MIDlet e
//implementando CommandListener (para executar comandos)
public class ExemploSomarDoisNumeros extends MIDlet implements
CommandListener {
//Cria os objetos
private Form meuFormulario;
private TextField valor1;
private TextField valor2;
private StringItem resultado;
//Cria um comando (neste caso, para sair do aplicativo)
private Command sairCommand;
//Cria um comando para somar os números
private Command somarCommand;
//Construtor criado para executar as funções apenas uma vez
//durante a primeira execução do MIDlet.
public ExemploSomarDoisNumeros() {
//Instancia o objeto com um novo Form e seu título
meuFormulario = new Form("Somar 2 Números");
//Instancia os objetos
valor1 = new TextField("Número 1: ", "", 5, TextField.NUMERIC);
valor2 = new TextField("Número 2: ", "", 5, TextField.NUMERIC);
resultado = new StringItem("Resultado: ", null);
78
//Insere os objetos no formulário
meuFormulario.append(valor1);
meuFormulario.append(valor2);
meuFormulario.append(resultado);
//Cria os comandos
sairCommand = new Command("Sair", Command.EXIT, 0);
somarCommand = new Command("Somar", Command.OK, 0);
//Adiciona os comandos ao formulário
meuFormulario.addCommand(sairCommand);
meuFormulario.addCommand(somarCommand);
//Adiciona o "monitoramento" de comandos
meuFormulario.setCommandListener(this);
}
//Método executado quando o MIDlet é iniciado pela primeira vez
//ou quando este retorna do estado Pausado.
public void startApp() {
//Captura o Display do celular e adiciona o
//Form criado para exibição.
Display.getDisplay(this).setCurrent(meuFormulario);
}
//Método executado quando o MIDlet vai entrar em estado Pausado.
public void pauseApp() {
}
//Método executado antes de finalizar o MIDlet.
public void destroyApp(boolean unconditional) {
//Avisa o SO que este pode controlar o display novamente
this.notifyDestroyed();
}
//Permite que a aplicação saiba quando um comando foi acionado
public void commandAction(Command c, Displayable d) {
//Compara o comando solicitado e executa a ação programada
if (c == sairCommand) {
destroyApp(true);
} else if (c == somarCommand) {
//Verifica os valores em cada TextField
//e converte de String para int
int nro1 = Integer.parseInt(valor1.getString());
int nro2 = Integer.parseInt(valor2.getString());
//Soma os dois valores
int soma = nro1 + nro2;
//Converte o resultado de int para string e insere
//no StringItem resultado
resultado.setText(String.valueOf(soma));
}
}
}
Quadro 10 - Código fonte exemplo de aplicação que soma dois números
79
Figura 42 - Exemplo de aplicação: Somar dois números
5.6.
Visão Geral do Ambiente de Desenvolvimento
Após o estudo das ferramentas e recursos envolvidos no processo de
desenvolvimento de software para telefones celulares, é apresentado, conforme
Figura 43, a visão geral do ambiente de desenvolvimento, contendo desde o sistema
operacional até as ferramentas utilizadas para criar e executar as aplicações móveis.
Figura 43 - Visão Geral do Ambiente de Desenvolvimento
Este
capítulo
apresentou
as
principais
ferramentas
utilizadas
no
desenvolvimento das aplicações. O Capítulo 6, a seguir, apresenta a tecnologia Web
Services, abordando sua utilização, arquitetura, vantagens, desvantagens e
exemplos de utilização.
80
6. WEB SERVICES
A necessidade de se obter acesso a redes e serviços remotamente fez surgir
os Web Services (WS), o que permitiu desenvolver uma grande variedade de
sistemas através da arquitetura cliente/servidor, onde sistemas distintos podem
interagir com estes servidores, mesmo sendo desenvolvidos em linguagens e
plataformas diferentes, ou que estejam localizados em lugares diferentes.
Toda comunicação e troca de dados é feita graças ao protocolo padrão dos
WS, o Extended Markup Language (XML), pois permite que sistemas sejam
acessados remotamente através da internet, efetuando trocas de informações de
forma transparente ao usuário.
De acordo com PARDAL [19], “os WS, resultam de uma iniciativa da
indústria de tecnologias de informação e comunicação para criar uma plataforma
universal de serviços para aplicações empresariais”.
PARDAL [19] Também afirma que:
Do ponto de vista técnico, um WS define uma interface funcional que pode
ser invocada remotamente para dar acesso a recursos. A designação Web
deve-se à inspiração na World Wide Web (WWW) e na forma como os
recursos são referenciados, por Identificador Uniforme de Recursos (URI).
Um WS é um sistema de software identificado por um Identificador Uniforme
de Recursos (URI), cujas interfaces públicas e ligações são definidas e descritas
usando XML, ou seja, “um WS é um aplicativo de software, acessível na web (ou em
uma intranet corporativa) através de uma URI, que é acessado pelos clientes
81
usando protocolos baseados em XML. Os WS expõem uma interface padronizada e
são independente de plataforma e de tecnologia.”
6.1. Utilização
Dentre as aplicações dos WS, podemos citar que o mesmo pode fornecer
uma maneira de expansão de negócios para a empresa, aumentando a eficiência e
melhorando a experiência com seus clientes, já que pode incluir serviços externos,
através de seus próprios serviços, como por exemplo, a utilização de cartões de
crédito e de serviços de entregas terceirizados, já que dependem de outras
empresas para funcionar sem problemas.
Além de ser responsável por solucionar os problemas de interoperabilidade
entre sistemas distintos os WS também possuem os objetivos de criar uma camada
de abstração entre nós heterogêneos (várias plataformas) em uma rede, ser
acessível em plataformas distintas e, reduzir custos de implantação e utilização de
servidores. [20]
6.2. Tecnologias
6.2.1. XML
O Extended Markup Language (XML) é uma linguagem de marcação criada
para introduzir novas possibilidades de integração entre os dados e os usuários.
Entende-se por marcação “um conjunto de convenções utilizadas para a codificação
de textos. Uma linguagem de marcação deve especificar que marcas são permitidas,
quais são exigidas, como se deve fazer distinção entre as marcas e o texto, e qual o
significado da marcação”. [21]
É ele quem provê um formato para descrever dados estruturados. Isso
facilita declarações mais precisas do conteúdo e resultados mais significativos de
busca através de múltiplas plataformas.
Surgiu como um subconjunto da Standart Generalized Markup Language
(SGML), criada em 1996, por um grupo de empresas e organizações denominado
W3C1 - World Wide Web Consortium. O W3C iniciou seus trabalhos em meados da
82
década de 1990, com o objetivo de criar uma nova metalinguagem (linguagem que
descreve outras linguagens) mais flexível e formal para uso na internet. [20]
O XML é utilizado nos WS para definir como os dados são representados,
como os serviços serão transmitidos, publicados e descobertos. É responsável pela
interação entre as aplicações e os WS, transportando os dados entre as diferentes
plataformas.
6.2.2. SOAP
De acordo com [22] e [23], apesar de não ser necessário conhecer o
funcionamento do protocolo para criar e consumir serviços, o Simple Object Access
Protocol (SOAP) é um dos elementos fundamentais dos WS. É o responsável por
lidar com situações de erros e problemas com a interoperabilidade e por permitir a
comunicação de dois processos em máquinas distintas com diferentes hardwares e
plataformas no uso dos WS.
Possui padrão aberto, e é por este motivo que o padrão foi adotado pela
grande maioria das empresas de hardware e software. A sua especificação é aberta
e provê a base para a comunicação de aplicação para aplicação: os Web Services.
Dentre as funcionalidades do SOAP, destacam-se a interoperabilidade entre
sistemas utilizando linguagens e protocolos padronizados como XML e HTTP,
permite comunicação entre sistemas com firewall, o que evita bloqueios de
comunicação, e, por fim, descreve cada elemento na mensagem, o que facilita o
entendimento e protege contra erros.
6.2.3. WSDL
Uma definição de Web Services Description Language (WSDL) é encontrada
em [24], onde define um sistema para a descrição de serviços. É através dela que
são descritos os serviços externos, ou interfaces que são oferecidas por uma
83
determinada aplicação, independente de sua plataforma ou linguagem de
programação.
Seu principal objetivo é descrever as interfaces apresentadas e apontar a
localização de seus serviços disponibilizados em um local conhecido por todos, onde
o cliente possa acessar os serviços de maneira confiável, ou seja, descreve os
serviços oferecidos para que os mesmos possam ser acessados pelos clientes. Por
ser um documento XML, sua leitura se torna fácil e acessível.
6.2.4. UDDI
O Universal Description Discovery and Integration (UDDI) é uma
especificação técnica, cujo objetivo é descrever, descobrir e integrar WS, ou seja,
publica os WS de forma transparente ao usuário para qualquer cliente. É um
elemento central do grupo de padrões que compõe a pilha de componentes dos
serviços web. [25]
O documento UDDI utiliza a mesma estrutura utilizada pelo SOAP e o
WSDL, ou seja, o XML, o que permite a independência de plataforma ou tecnologia
a ser utilizada.
Hartwig GUNZER, em [26], mostra que UDDI é um padrão que foi
desenvolvido para fornecer um diretório de busca para os negócios e seus serviços,
cujo objetivo é ser um mediador do serviço, permitindo que os clientes requisitantes
encontrem um fornecedor do serviço apropriado.
GUNZER divide o documento UDDI em três partes:
Páginas amarelas: Buscas podem ser feitas para encontrar serviços de
uma determinada indústria, empresa, de uma categoria de produtos ou que estão
localizados dentro de uma região geográfica específica.
Páginas Brancas: Contém informações sobre as empresas fornecedoras
dos serviços, incluindo endereços para contatos e outros identificadores.
84
Páginas Verdes: Contém informações técnicas sobre os WS que estão
expostos pela empresa. Mostra como comunicar com o serviço.
6.3.
Arquitetura Básica dos Web Services
De acordo com [27], a arquitetura básica dos WS é apoiada na interação de
três elementos, o que envolve as operações de publicação, pesquisa e ligação,
sendo eles, Provedor de Serviços, Registro de Serviços e Consumidor de Serviços.
Provedor de Serviços: É responsável pela criação do WS. O provedor
disponibiliza o serviço para que o cliente possa utilizar. O WS deve ser descrito pelo
provedor em um formato padrão para que possa ser compreendido por qualquer
aplicação desenvolvida em qualquer linguagem a partir de qualquer plataforma.
Registro de Serviços: É a localização de onde um provedor de serviços
pode disponibilizar seus WS para que os consumidores de serviços possam
pesquisar os mesmos. Possui também, a informações sobre as empresas, os
serviços que elas disponibilizam, bem como a descrição técnica de cada serviço.
Consumidor de Serviços: É o cliente do WS, ou seja, é qualquer aplicação
que tenha capacidade de usar um dos WS criados pelo provedor de serviços. É o
consumidor que conhece as funcionalidades do WS a partir da descrição disposta
pelo provedor e recupera os detalhes através de uma pesquisa no registro de
serviços para obter o mecanismo de ligação com o WS.
6.4.
Vantagens
Também são destacadas algumas vantagens que os Web Services
proporcionam. [20]
• Integração de sistemas legados – é a capacidade de integrar sistemas de
empresas diferentes já finalizados.
85
• Diminuição de custos operacionais – a internet é o principal responsável pela
redução de custos, pois não será necessário montar nenhum tipo especial de
rede.
• Desenvolvimento
de
sistemas
mais
rápido
–
as
ferramentas
de
desenvolvimento atuais dão suporte a criação de WS, através de assistentes.
• Melhor comunicação e integração com consumidores e parceiros comerciais
externos.
6.5. Desvantagens
Ainda em [20], são destacadas algumas desvantagens.
• Disponibilidade – Como a internet é o meio de comunicação dos WS, não há
garantias de uma completa disponibilidade dos serviços, já que falhas podem
ocorrer e a conexão com a internet pode ficar inativa.
• Garantia de execução – por usar HTTP, não há garantias de recebimento de
resposta. Para haver esta garantia, deve-se usar Java Message Service
(JMS).
• Problemas de desempenho – a velocidade da internet, bem como o
desempenho ao converter os documentos XML devem ser analisados para
evitar congestionamentos e falhas no servidor.
6.6. Apache Tomcat v.7
Apache Tomcat, ou simplesmente Tomcat, é um container servlet
desenvolvido pela Apache Software Foundation (ASF). Um Servlet é uma aplicação
que roda diretamente no servidor desenvolvida em Java cuja finalidade é fornecer
recursos adicionais para os servidores web. O Tomcat também implementa as
especificações JavaServer Pages (JSP) da Sun Microsystems [28].
86
JSP é uma tecnologia utilizada no desenvolvimento de aplicações para Web.
Pode ser desenvolvida em Java, com a vantagem de ser multiplataforma. Esta
tecnologia permite produzir aplicações que acessem o banco de dados, manipulem
arquivos no formato texto, capturem informações a partir de formulários e captem
informações sobre o visitante e sobre o servidor.
6.7. Apache Axis v1.4
O Apache Axis é um framework de código aberto, baseado na linguagem
Java e no padrão XML, utilizado para construção de WS no padrão SOAP. Também
implementado em C, o Axis permite criar aplicações distribuídas. É suportado pela
Apache Software Foundation.
Existem dois métodos para publicar os métodos de uma classe dos WS: a
primeira delas é mais simples e utiliza arquivos do tipo Java Web Service (JWS) e a
segunda utiliza um arquivo denominado Web Service Deployment Descriptor
(WSDD) que descreve com detalhes como serão criados os WS a partir das classes
existentes [30].
O Axis também gera automaticamente o arquivo WSDL (Web Service
Description Language) contendo a definição da interface dos WS.
O Apache Axis será utilizado para publicar os WS. Este servidor foi
escolhido por apresentar velocidade superior comparado a outros servidores, como
o Glassfish v2 e v3, e ainda, por mostrar-se robusto em fornecer os serviços sem
erros de resposta e sem problemas quanto à disponibilidade, ou seja, sem sair “do
ar”.
6.8. Instalação do Apache Tomcat e Apache Axis
A instalação do Apache Tomcat e Axis é muito simples. Ambos podem ser
encontrados
para
download
nos
seguintes
endereços
http://tomcat.apache.org/download-70.cgi (Figura 44) e http://linorg.usp.br/apache//
ws/axis/1_4/ (Figura 45) respectivamente.
87
Figura 44 - Download do Apache Tomcat 7
Figura 45 - Download do Apache Axis 1.4
Quanto à instalação é muito simples. O Apache Tomcat para versão
Windows é um arquivo executável e segue o padrão. A instalação do Apache Axis
deve ser feita através da descompactação dos arquivos na pasta “webapps” do
Tomcat, geralmente em “C:\Program Files\Tomcat7.0\webapps”.
Para
executar
os
servidores,
acessar
o
Menu
IniciarTodos
os
programasApache Tomcat 7.0Monitor Tomcat. Aparecerá próximo ao relógio do
Windows um ícone. Clicando com o botão direito é possível iniciar/parar o servidor
(Figura 46).
88
Figura 46 - Iniciar/parar Apache Tomcat.
6.9. Desenvolvendo um Web Service simples
A maneira mais fácil de desenvolver um WS é criar um arquivo com a
extensão .jws e salvá-lo na pasta onde foi instalado o Apache Axis, geralmente em
“C:\Program Files\Tomcat7.0\webapps\axis”.
O arquivo consiste na criação de uma classe Java onde os métodos desta
classe serão os métodos disponibilizados no WS. O Código abaixo mostra a criação
de um simples WS que recebe como parâmetro dois valores e retorna a soma
destes.
Para acessar os recursos disponibilizados pelo WS basta acessar o
endereço “http://localhost:8080/axis/tcc.jws?wsdl” (endereço do computador + nome
do servidor + arquivo do WS + parâmetro WSDL) para verificar os métodos e suas
propriedades através do arquivo WSDL disponibilizado no formato XML, como a
seguir.
− <wsdl:definitionstargetNamespace="http://localhost:8080/axis/tcc.jws">
− <!-WSDL created by Apache Axis version: 1.4
Built on Apr 22, 2006 (06:55:48 PDT)
-->
− <wsdl:messagename="somaResponse">
<wsdl:partname="somaReturn"type="xsd:int"/>
</wsdl:message>
− <wsdl:messagename="somaRequest">
<wsdl:partname="valor1"type="xsd:int"/>
<wsdl:partname="valor2"type="xsd:int"/>
</wsdl:message>
− <wsdl:portTypename="tcc">
− <wsdl:operationname="soma"parameterOrder="valor1 valor2">
<wsdl:inputmessage="impl:somaRequest"name="somaRequest"/>
<wsdl:outputmessage="impl:somaResponse"name="somaResponse"/>
89
</wsdl:operation>
</wsdl:portType>
− <wsdl:bindingname="tccSoapBinding"type="impl:tcc">
<wsdlsoap:bindingstyle="rpc"transport="http://schemas.xmlsoap.org/soap/http"/>
− <wsdl:operationname="soma">
<wsdlsoap:operationsoapAction=""/>
− <wsdl:inputname="somaRequest">
<wsdlsoap:bodyencodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
namespace="http://DefaultNamespace"use="encoded"/>
</wsdl:input>
− <wsdl:outputname="somaResponse">
<wsdlsoap:bodyencodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
namespace="http://localhost:8080/axis/tcc.jws"use="encoded"/>
</wsdl:output>
</wsdl:operation>
</wsdl:binding>
− <wsdl:servicename="tccService">
− <wsdl:portbinding="impl:tccSoapBinding"name="tcc">
<wsdlsoap:addresslocation="http://localhost:8080/axis/tcc.jws"/>
</wsdl:port>
</wsdl:service>
</wsdl:definitions>
Quadro 11 - WSDL do Web Service
Para consumir um método do WS utilizando o navegador, basta acessar o
endereço “http://localhost:8080/axis/tcc.jws?method=soma&valor1= 10&valor2=20”.
Formato: Endereço do computador + nome do servidor + arquivo do WS + método +
parâmetros e seus valores. O XML de resposta é o seguinte:
− <soapenv:Envelope>
− <soapenv:Body>
− <somaResponsesoapenv:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
<somaReturnxsi:type="xsd:int">30</somaReturn>
</somaResponse>
</soapenv:Body>
</soapenv:Envelope>
Quadro 12 - XML com a resposta da chamada de um método do WS pelo Browser
Pode-se perceber que o resultado retorna encapsulado em um envelope
SOAP. Também fica explícito que o resultado (número 30) é do tipo int. Esta
informação é importante para o programador poder tratar estes resultados em suas
aplicações.
90
6.10. Exemplo de aplicação: Somar dois números utilizando WS
O exemplo desenvolvido no Capítulo 5.5.6 será utilizado como base para a
utilização do WS. É importante ressaltar que um telefone celular geralmente não
possui métodos nativos para acessar os WS, portanto utiliza-se as bibliotecas
kSOAP e kXML para efetuar a comunicação do dispositivo com o servidor.
6.10.1.
kSOAP e kXML
A comunicação das aplicações J2ME com os WS é feita através da troca de
mensagens em XML utilizando o protocolo SOAP. Como o J2ME não possui classes
nativas que tratam estas implementações, faz-se necessário utilizar dois projetos
para atender as transparências entre as trocas de informações. Os projetos são o
KSOAP e o KXML mantidos pela ObjectWeb e ambos estão sob licença pública [30].
A utilização destes dois projetos permite que qualquer celular com os
requisitos mínimos (i.e., rodar aplicativos em Java e suportar MIDP 2.0) consiga
acessar os WS através da internet, uma vez que os recursos necessários ficam
embutidos na aplicação. Também substitui a utilização da Application Programming
Interface (API) Java Specification Requests (JSR) 172, que apesar de ser mais
prático quanto sua utilização e efetuar o mesmo processo de conexão, só existe em
um número muito limitado de aparelhos, prejudicando assim, a portabilidade.
6.10.2.
Modificando o projeto para conectar ao Web Services
Primeiramente é necessário adicionar as bibliotecas kSOAP e kXML ao
projeto. Descompactar os arquivos das bibliotecas adquiridos em [30] na pasta “src”
do projeto criado pelo Netbeans. Após a inserção das bibliotecas, basta importar os
pacotes destas, e efetuar as seguintes alterações, conforme o código a seguir.
91
//importa a classe midlet
import java.io.IOException;
import javax.microedition.midlet.*;
//importa a classe lcdui
import javax.microedition.lcdui.*;
//importa as bibliotecas para conectar no Web Service
import org.ksoap.SoapObject;
import org.ksoap.transport.HttpTransport;
/**
* @author Fabio
*/
//Classe principal do MIDlet estendida de MIDlet e
//implementando CommandListener (para executar comandos)
public class ExemploSomarDoisNumerosWS extends MIDlet implements CommandListener {
//Cria os objetos
private Form meuFormulario;
private TextField valor1;
private TextField valor2;
private StringItem resultado;
//Cria um comando (neste caso, para sair do aplicativo)
private Command sairCommand;
//Cria um comando para somar os números
private Command somarCommand;
//Construtor criado para executar as funções apenas uma vez durante a
//primeira execução do MIDlet.
public ExemploSomarDoisNumerosWS() {
//Instancia o objeto com um novo Form e seu título
meuFormulario = new Form("Somar 2 Números");
//Instancia os objetos
valor1 = new TextField("Número 1: ", "", 5, TextField.NUMERIC);
valor2 = new TextField("Número 2: ", "", 5, TextField.NUMERIC);
resultado = new StringItem("Resultado do WS: ", null);
//Insere os objetos no formulário
meuFormulario.append(valor1);
meuFormulario.append(valor2);
meuFormulario.append(resultado);
//Cria os comandos
sairCommand = new Command("Sair", Command.EXIT, 0);
somarCommand = new Command("Somar", Command.OK, 0);
//Adiciona os comandos ao formulário
meuFormulario.addCommand(sairCommand);
meuFormulario.addCommand(somarCommand);
//Adiciona o "monitoramento" de comandos
meuFormulario.setCommandListener(this);
}
//Método executado quando o MIDlet é iniciado pela primeira vez
//ou quando este retorna do estado Pausado.
public void startApp() {
//Captura o Display do celular e adiciona o Form criado para exibição.
Display.getDisplay(this).setCurrent(meuFormulario);
}
//Método executado quando o MIDlet vai entrar em estado Pausado.
public void pauseApp() {
}
//Método executado antes de finalizar o MIDlet.
public void destroyApp(boolean unconditional) {
//Avisa o SO que este pode controlar o display/dispositivo novamente
this.notifyDestroyed();
92
}
//Permite que a aplicação saiba quando um comando foi acionado
public void commandAction(Command c, Displayable d) {
//Compara qual comando foi solicitado e executa alguma ação programada
if (c == sairCommand) {
destroyApp(true);
} else if (c == somarCommand) {
//define o endereço do servidor
String enderecoWS = "http://192.168.1.125:8080/axis/tcc.jws";
//cria um StringBuffer para armazenar o resultado do WS
StringBuffer stringBuffer = new StringBuffer();
//Cria o objeto SOAP cliente e instancia a classe SoapObject
//Parâmetros: Endereço do WS + nome do método
SoapObject client = new SoapObject(enderecoWS, "soma");
//adiciona os parâmetros do Web Service
//OBS: o método do WS necessita de Integers como parâmetros
client.addProperty("valor1", new
Integer(Integer.parseInt(valor1.getString())));
client.addProperty("valor2", new
Integer(Integer.parseInt(valor2.getString())));
//cria uma conexão com o Web Service
//Parâmetros: Endereço do WS + nome do método
HttpTransport ht = new HttpTransport(enderecoWS, "soma");
//utiliza a estrutura try para tratamento de exceções
try {
//chama o método no Web Service
stringBuffer.append(ht.call(client));
} catch (org.ksoap.SoapFault e) {
//em caso de erros, mostra o erro no log
e.printStackTrace();
} catch (IOException e) {
//em caso de erro, cria um alerta de erro de conexão
Alert alertaConexao = new Alert("Erro!", "Erro ao conectar com o
servidor!", null, AlertType.ERROR);
//exibe o alerta
Display.getDisplay(this).setCurrent(alertaConexao, meuFormulario);
//mostra o erro no log
e.printStackTrace();
}
//Converte o resultado do WS para String
String resultadoWS = stringBuffer.toString();
//Insere o resultado no StringItem resultado
resultado.setText(String.valueOf(resultadoWS));
}
}
}
Quadro 13 - Código fonte da aplicação de exemplo com WS
Figura 47 - Exemplo de aplicação: Somar dois números utilizando Web Services
93
7. ESTUDO DE CASO: ADIÇÃO DE UM MÓDULO MÓVEL AO SISTEMA DE
MONITORAMENTO EM SUBESTAÇÕES DE ENERGIA ELÉTRICA
7.1.
Sistema De Monitoramento Em Subestações De Energia Elétrica
O Sistema de Monitoramento em Subestações de Energia Elétrica é
resultado de pesquisas realizadas pelo Grupo de Automação Industrial e Controle
(GAIC), situado no Departamento de Tecnologia da Unijuí, juntamente com o apoio
da CEEE-D/RS.
O desenvolvimento do sistema de monitoramento, de acordo com [31],
fornece garantias de fornecimento de energia elétrica de qualidade, pois permite
monitorar em tempo real uma subestação de energia elétrica onde é possível
perceber instantaneamente as variações e distúrbios ocorridos. Afirma também que
é possível identificar prováveis problemas de forma rápida e precisa. Ao aliar estas
possibilidades com os recursos da microinformática, pode-se obter o controle de
qualidade da energia elétrica fornecida.
Também permite que todos os dados coletados sejam armazenados em um
banco de dados para posterior análise, onde é possível verificar a ocorrência de
erros, em como analisar as grandezas coletadas, os horário de maior consumo, bem
como traçar metas e meios para economia de energia.
O sistema como um todo possui três subdivisões interconectadas, sendo
elas Subsistema de Aquisição de Dados, Subsistema Servidor Remoto e
Subsistema Controlador Supervisório, conforme figura a seguir: [32]
94
Figura 48 - Arquitetura do Sistema de Monitoramento de Subestações de Energia Elétrica
7.1.1. Subsistema De Aquisição De Dados
O subsistema de aquisição de dados é responsável pela coleta e
manipulação de dados através de dispositivos denominados Unidades Remotas de
Aquisição de Dados (URAD - Figura 49) [33] e [31]. A URAD captura os valores de
três tensões e três correntes através de seus sensores e transdutores, onde a partir
destas informações coletadas, calcula as variáveis de Potência Ativa, Potência
Aparente e o Fator de Potência (grandezas).
A URAD dispõe de seis entradas analógicas e quatro entradas digitais, o que
permite a captura de dados para efetuar o monitoramento dos sistemas elétricos de
potência. Possui, também, quatro saídas digitais para interagir com o sistema, caso
seja necessário. [31]
De acordo como [34], a URAD pode se comunicar com o Servidor Remoto
(SR) através de porta serial (RS 232), via ondas de rádio ou ainda pela RS 485
(multiponto, maiores distâncias de transmissão) que permite conectar diversas
URADs para cada SR.
95
Figura 49 - Unidade Remota de Aquisição de Dados (URAD)
7.1.2. Subsistema Servidor Remoto
O subsistema servidor remoto (Figura 50), de acordo com [33], funciona
como um gateway na rede. É ele quem permite a comunicação entre o subsistema
de aquisição de dados e o subsistema controlador supervisório, transmitindo os
dados recebidos da URAD para o computador com o sistema de exibição das
grandezas coletadas e posterior gravação dos mesmos do banco de dados.
O equipamento utilizado no Servidor Remoto é uma Soekris modelo Net4521
que permite trabalhos sob severas condições de funcionamento, dotado de
processador AMD de 133MHZ, 64MB SDRAM, duas interfaces FastEthernet, socket
CompactFlash tipo I/II, dois slots PC-Card/Cardbus, portal serial DB9 e é alimentado
com fonte externa de 12V. [35]
Figura 50 - Servidor Remoto (SR): 1. Placa PCMCIA Orinoco; 2. Conexão SR com a rede
Ethernet; 3. Conexão SR com a URAD; 4. Alimentação e 5. Cartão de memória
96
7.1.3. Subsistema Controlador Supervisório
O Subsistema Controlador Supervisório é um aplicativo desenvolvido em
linguagem Java que exibe as grandezas capturadas pela URAD em forma de
gráficos, e as armazena do Sistema de Gerenciamento de Banco de Dados (SGBD)
IBM DB2 Express-C para posterior análise e para gerar relatórios.
O sistema (Figura 51) também permite monitoramento em tempo real, onde
em caso de alteração além nos limites estabelecidos, dispara alarmes indicando sub
e sobretensão. Permite visualização do sistema tanto no computador em que está
instalado, bem como através do browser, pela internet, o que admite monitoramento
remoto. [36]
Figura 51 - Tela do aplicativo de monitoramento
97
7.2.
Protótipo Do Subsistema Móvel Incorporado
Com o intuito de aplicar os conhecimentos adquiridos e verificar a viabilidade
de aplicação da tecnologia J2ME em benefício de um Sistema de Monitoramento de
Subestações de Energia Elétrica através de um telefone celular, foi desenvolvido um
protótipo para monitoramento remoto, utilizando WS.
O objetivo é fornecer um aplicativo para monitoramento remoto das
grandezas trabalhadas na subestação de energia, através de um aparelho celular,
proporcionando maior facilidade e confiabilidade no fornecimento de energia elétrica.
Ao utilizar recursos móveis, as funções de controle dos equipamentos
podem ser acessadas de qualquer local e a qualquer momento dentro da empresa,
através da cobertura de rede sem fio, desde que o usuário tenha equipamento
compatível, ou até mesmo fora da empresa, utilizando conexão de dados da
operadora de celular, o que possibilita a ausência do responsável perante estes
equipamentos e a atuação em outros setores da empresa.
7.2.1.
Funcionamento Geral Da Aplicação
O protótipo da aplicação desenvolvida para o Subsistema Móvel foi escrita
utilizando a tecnologia J2ME. Seu funcionamento pode ser visualizado de acordo
com o diagrama de telas apresentado pela Figura 52.
98
Figura 52 - Diagrama de telas da aplicação de monitoramento
A utilização da aplicação por parte do usuário é muito simples, devido a
presença de um menu no formato grade, semelhante à navegação entre as
funcionalidades de muitos telefones celulares. Com a aplicação em execução, o
usuário pode selecionar uma das grandezas para visualizar o gráfico com as
variações das leituras efetuadas pela URAD, através do Subsistema de Aquisição de
Dados. Mais detalhes de cada etapa do Subsistema Móvel serão vistos a seguir.
7.2.2.
Menu
O menu é disposto no formato grade, contendo onze ícones, conforme
Figura 53. Os nove primeiros ícones representam cada uma das grandezas
trabalhadas na subestação de energia e permitem a exibição dos gráficos em tempo
99
real. A utilização deste menu facilita a navegação dentro da aplicação, uma vez que
possui ícones ilustrativos com uma legenda de sua respectiva função.
No desenvolvimento desta tela de menu foi utilizada a interface de baixo
nível Canvas, pois nela existe a liberdade de se desenhar os componentes e ajustas
suas respectivas posições, fato que não é possível ao utilizar uma interface de alto
nível. A interface Canvas também permite que a aplicação seja executada no modo
tela cheia, ou seja, possibilita o aumento de 27% da área visível da tela para a
exibição dos elementos da aplicação.
Figura 53 - Menu da aplicação de Monitoramento
7.2.3.
Gráficos
Ao selecionar uma das grandezas do menu, a aplicação passa a exibir uma
tela (Figura 54) com o nome da grandeza selecionada, os valores mínimo e máximo
correspondente às leituras da URAD, um gráfico com a variação destas leituras e,
por fim, o valor da leitura atual. Também são exibidos alertas (subtensão,
sobretensão e sobrecarga), em caso de ultrapassagem dos limites estabelecidos
nas configurações do aplicativo.
100
Figura 54 - Gráficos gerados pela aplicação de Monitoramento
Os gráficos são gerados com o auxílio da API ChartComponent versão 1.5.2
[37]. O ChartComponent é uma API gráfica desenvolvida pela organização Beanizer,
sob utilização pública. A API permite a criação de gráficos no formato de barras
verticais, horizontais, pizza e gráfico de linhas. O principal motivo de sua utilização é
o fato de ser possível criar facilmente gráficos com melhor aparência e riqueza de
detalhes para as aplicações em J2ME.
Ao gerar o gráfico pela primeira vez, a aplicação efetua uma consulta ao WS
e coleta os últimos 50 dados armazenados no SGBD. Após gerar a primeira imagem
do gráfico, este é atualizado em um determinado tempo em segundos, definido pelo
usuário na tela de configurações (Capítulo 7.2.5), onde é feita a exclusão do primeiro
valor e é adicionado um novo valor no final, valor este proveniente de novas
consultas ao WS. Esta atualização do gráfico é feita de forma contínua, dando
visibilidade de uma leitura em tempo real.
7.2.4.
Conexão com o Web Services
Os dados exibidos na tela do telefone celular são obtidos através da conexão
entre o aplicativo e o WS. O aplicativo possui uma Thread (a qual possibilita que
instruções sejam executadas em paralelo à aplicação) responsável por invocar os
métodos descritos no WS, ou seja, efetuar as conexões com o servidor e obter os
dados recuperados do SGBD.
O WS dispõe de dois métodos que efetuam a conexão e as consultas com o
SGBD. O primeiro método busca os últimos 50 dados armazenados, enquanto o
101
segundo método busca apenas o último dados. O Quadro 14 apresenta o código
fonte utilizado no primeiro método, criado conforme Capítulo 6.9.
//Importa os drivers necessários para comunicar com o SGBD
import java.lang.Integer;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.ResultSet;
//Cria a classe do WS
public class Servico {
//Cria as variáveis de conexão
public Connection con;
public Statement stmt;
public ResultSet res;
//Cria o método de consulta utilizado pelo aplicativo do celular
public Integer[] celular50(String coluna) {
Integer[] dados = null;
int i = 0;
try {
//Efetua a conexão com o SGBD
Class.forName("com.ibm.db2.jcc.DB2Driver");
String connecturl = "jdbc:db2://IP_do_servidor:50001/Nome_BD";
con = DriverManager.getConnection(connecturl, "usuárioBD", "senhaBD");
} catch (ClassNotFoundException ex) {
System.out.println("Classe não encontrada");
} catch (SQLException e) {
System.out.println("Erro de SQL");
}
try {
//Executa a SQL
stmt = con.createStatement();
res = stmt.executeQuery("select " + coluna + " from MEDIDAS order by
datahora desc fetch first 50 rows only");
dados = new Integer[50];
//Prepara o resultado
while (res.next()) {
dados[i++] = res.getInt(coluna);
}
con.close();
//Retorna os dados lidos no SGBD
return dados;
} catch (SQLException ex) {
return new Integer[]{0};
}
}
}
Quadro 14 - Método do WS da aplicação de Monitoramento
Os dados transmitidos entre o servidor e a aplicação são envelopados no
protocolo SOAP 1.2 utilizando XML. Pelo fato de o J2ME não possuir classes nativas
que implementam este protocolo, é necessário utilizar dois projetos externos, o
kXML e o kSOAP, descritos no Capítulo 6.10.1, os quais substituem o uso da API
JSR 172, presente em alguns aparelhos.
102
7.2.5.
Configurações
As informações necessárias para efetuar a conexão com o servidor, bem
como os limites que devem ser estabelecidos para o correto funcionamento dos
gráficos e seus alertas são manipulados através das configurações do aplicativo,
acessadas por um ícone dedicado no menu do aplicativo.
Estes dados são armazenados no telefone celular através da tecnologia
Record Management System (RMS), este que persistente aos dados nos
dispositivos móveis em uma memória não volátil e possui similaridade a um banco
de dados em sistemas Stand-alone (i.e., que funciona sozinho).
A tela foi desenvolvida utilizando elementos da interface de alto nível (Figura
55). Possui um alerta do tipo Confirmation para indicar o momento em que as
configurações são armazenadas, juntamente com outro alerta do tipo Confirmation
para informar ao usuário, ao executar o aplicativo pela primeira vez, de que as
configurações não foram realizadas, indagando o usuário se este deseja partir
diretamente para a tela de configurações.
Figura 55 - Configurações do aplicativo de Monitoramento
7.2.6.
Outras tecnologias utilizadas
As
características
deste
sistema
exigem
tanto
um
ambiente
de
desenvolvimento quanto um ambiente de execução livres de custo. Nesta situação,
103
foi utilizado uma distribuição Linux, como o sistema operacional OpenSUSE v.11.1,
por tratar-se de uma distribuição estável e livre de custo, desenvolvida pela
comunidade openSUSE.
O SGBD utilizado será o DB2 Express-C da IBM, nesta versão, um robusto
SGBD baseado na tecnologia de software livre com uma crescente comunidade de
desenvolvedores, e já se encontra implementado em diversas soluções de negócios.
Versão esta desenvolvida, também, para estudantes que desejam conhecer e
trabalhar com o SGBD em questão [38].
O motivo pela escolha deste SGBD foi pela vantagem de o mesmo ser free,
por ser multiplataforma, ou seja, por ser desenvolvido em software livre e, também,
por poder reaproveitar a base de dados já existente no projeto principal, como
especificado em [39].
A estrutura da base de dados será reaproveitada do projeto já existente
(Sistema de Monitoramento em Subestações de Energia Elétrica), onde serão
recuperados os últimos dados gravados neste banco de dados para exibição no
aplicativo a ser criado para o celular.
7.3.
Considerações Finais do Protótipo Desenvolvido
O protótipo desenvolvido para o monitoramento remoto da subestação de
energia elétrica apresentou um funcionamento ideal, tanto em ambiente de testes
quanto em um ambiente real. Disponibilizou o desenvolvimento de uma aplicação
com alto grau de confiabilidade e com reduzido custo de produção, manutenção e
utilização.
O diferencial deste sistema foi a exigência da utilização de tecnologias livres
de custo. Pelo fato de a aplicação e o WS serem construídos em linguagem Java,
portanto, multiplataforma, houve uma grande facilidade de implantar o servidor e o
sistema como um todo em ambiente Linux.
104
A utilização de tecnologias livres proporcionou uma redução significativa nos
custos de produção e manutenção, dando ao sistema características flexíveis e
dinâmicas por permitir o monitoramento dos equipamentos fora da empresa em
questão.
No ambiente real, a aplicação mostrou-se eficaz tanto em rede interna
utilizando Wi-Fi, apesar do alcance do sinal ser relativamente baixo, quanto em rede
GSM ou 3G, onde a cobertura de sinal da telefonia móvel pode atingir longas
distâncias.
Por
fim,
destaca-se
o
uso
de
WS
para
comunicação
entre
aplicativos/sistemas disponíveis em diferentes plataformas e linguagens de
programação.
105
CONCLUSÃO
Através deste trabalho, foi possível realizar um estudo sobre o sistema
operacional Symbian, bem como as ferramentas de desenvolvimento de aplicativos
para telefones celulares que utilizam este SO. Também foram apresentados os
requisitos necessários para a utilização destes aplicativos na interação com
servidores remotos utilizando Web Services.
Com o estudo da plataforma J2ME notou-se que esta disponibiliza diversas
funcionalidades que permitem criar aplicativos para suprir as necessidades das mais
variadas situações, tanto de usuários comuns quanto de empresas.
Neste sentido, a disposição de ferramentas e a explanação dos recursos
oferecidos por estas, possibilitou o desenvolvimento do protótipo para o
monitoramento remoto da Subestação de Energia Elétrica disponível em [39].
O protótipo do sistema móvel permite um melhor controle sobre os
equipamentos da subestação. Sua utilização torna a tarefa de monitoramento
flexível e dinâmica, permitindo monitorar remotamente, através de gráficos, as
grandezas trabalhadas na subestação de energia, tornando dispensável a presença
de um técnico em tempo integral para monitorar os equipamento dentro da empresa.
A utilização de Softwares livres atendeu todas as expectativas, e, além de
serem livres de custo, possuem uma vasta comunidade de desenvolvedores que
dão suporte tanto para sua utilização, quanto para o desenvolvimento. Diante disso,
foi possível verificar a viabilidade do desenvolvimento do protótipo e disponibilizar a
106
comunicação com um servidor de dados para buscar e receber estes dados,
integrando a aplicação ao sistema de monitoramento existente.
Trabalhos Futuros
Após o desenvolvimento do protótipo, algumas sugestões podem ser dadas
para aprimorar as funcionalidades do mesmo. Dentre as quais podem-se destacar:
•
Melhoramento do WS no servidor, em busca de tecnologias e soluções que
possam melhorar ainda mais o desempenho de resposta do WS;
•
Ampliar a portabilidade, efetuando testes em outros dispositivos com o SO
Symbian;
•
Ampliar ainda mais a portabilidade, desenvolvendo softwares para outras
plataformas de dispositivos móveis.
107
REFERÊNCIAS BIBLIOGRÁFICAS
[1] OGLIARI, Ricardo. Sony Ericsson e Samsung abandonam definitivamente o
Symbian. Disponível em <http://www.mobilidadetudo.com/ 2010/10/sony-ericsson-esamsung-abandonam-definitivamente-o-symbian.html>, acessado em 10/10/2010.
[2] BARRETO, Juliano. Participação no mercado de smartphones (em %).
Revista Info, no 296, pg. 32. Editora Abril. Outubro de 2010.
[3] GARTNER. Gartner Says Worldwide Mobile Phone Sales Grew 35 Percent in
Third Quarter 2010; Smartphone Sales Increased 96 Percent. Disponível em:
<http://www.gartner.com/it/page.jsp?id=1466313>, acessado em 20/11/2010.
[4] MORRIS, Ben. The Symbian OS Architecture Sourcebook – Design and
Evolution of a Mobile Phone OS. Symbian Press. John Wiley & Sons, Ltd. 2007.
[5] STEVE, Babin. Developing Software for Symbian OS - An Introduction to
Creating Smartphone Applications in C++. Symbian Press. John Wiley & Sons,
Ltd. 2006.
[6] EDWARDS, Reuben; COULTON, Paul; CLEMSON, Helen. S60 Programming –
A tutorial Guide. Symbian Press. John Wiley & Sons, Ltd. 2007.
[7] MUCHOW, John W. Core J2ME: Tecnologia e MIDP. The Sun Microsystems
Press. Pearson, São Paulo. 2006.
[8] JOHNSON, Thienne M. Java para dispositivos Móveis. Novatec Editora Ltda.
2008
[9] ZANFOLIM, Lais Claudia; FERNANDES, Rodolfo Chaves. Desenvolvendo um
Estudo de Caso Utilizando a Plataforma Java ME. Universidade Estadual de Mato
Grosso do Sul. Dezembro de 2009. Disponível em: <http://www.slide
share.net/chavesrodolfo/desenvolvendo-um-estudo-de-caso-utilizando-a-plataformajava-me>, acessado em 10/11/2010.
[10] Foundation Profile. Disponível em: <http://java.sun.com/products/ foundation/>,
acessado em 14/11/2010.
108
[11] Personal Basis Profile.
Disponível
products/personalbasis/>, acessado em 14/11/2010.
em:
<http://java.sun.com/
[12] Personal Profile. Disponível em: <http://java.sun.com/products/personal
profile/>, acessado em 14/11/2010.
[13] VINAGRE, André Nobre; VIANA, David Henrique de Moura. Desenvolvendo
em J2ME: afinando com o celular. Disponível em: <http://www.webartigos.com/
articles/7853/1/Desenvolvendo-Em-J2me/pagina1.html>, acessado em 15/11/2010.
[14] MID Profile Documentation. Disponível em: <http://download.oracle.
com/javame/config/cldc/ref-impl/midp2.0/jsr118/index.html>,
acessado
em
15/11/2010.
[15] O Netbeans. Disponível em: <www.guj.com.br/content/articles/netbeans/
aplicacoes_com_netbeans.pdf>, acessado em 18/09/2010.
[16] O que é o NetBeans. Disponível
index_pt_BR.html>, acessado em 18/09/2010.
em
<http://www.netbeans.org/
[17] Fórum Nokia.com – S60 3rd Edition FP2 SDK. Disponível
<http://www.forum.nokia.com/info/sw.nokia.com/id/ec866fab-4b76-49f6-b5a5af0631419e9c/S60_All_in_One_SDKs.html/>, acessado em 18/09/2010.
em
[18]
ActivePerl
–
Site
Oficial.
Disponível
<http://www.activestate.com/activeperl/downloads>, acessado em 21/11/2010.
em:
[19] PARDAL, Miguel Felipe Leitão. Segurança de aplicações empresariais em
arquiteturas
de
serviços.
2006.
Disponível
em:
<http://mflpar.googlepages.com/MScMflp20060908.pdf>, acessado em 27/08/2010.
[20] MACHADO, Alencar Utilização de Dispositivos Móveis e Web Services no
Monitoramento de Pacientes. Trabalho de Conclusão de Curso. Unijuí, 2008.
[21] ALMEIDA, Maurício Barcellos. Uma introdução ao XML, sua utilização na
Internet e alguns conceitos complementares. Universidade Federal de Minas
Gerais.
Minas
Gerais,
2002.
Disponível
em
<http://www.scielo.br/
pdf/ci/v31n2/12903.pdf>, acessado em 18/09/2010.
[22] LEOPOLDO, Marcus Rommel Barbosa. Simple Object Access Protocol Entendendo o Simple Object Access Protocol (SOAP). Disponível em
<http://www.msdnbrasil.com.br/secure/sharepedia/arquivos/SOAP.pdf>,
acessado
em 18/09/2010.
[23] RECKZIEGEL, Mauricio. Protocolo de Transporte Padrão – SOAP. Disponível
em
<http://imasters.uol.com.br/artigo/4379/webservices/protocolo_de_transporte_
padrao_-_soap/>, acessado em 23/10/2010.
109
[24] RECKZIEGEL, Mauricio. Descrevendo um Web Service – WSDL. Disponível
em
<http://imasters.uol.com.br/artigo/4422/webservices/descrevendo_um_web_
service_-_wsdl/>, acessado em 23/10/2010.
[25] [RECKZIEGEL, Mauricio. Descrevendo, descobrindo e integrando Web
Services - UDDI. Disponível em <http://imasters.uol.com.br/artigo/4474/
webservices/descrevendo_descobrindo_e_integrando_web_services_-_uddi/>,
acessado em acessado em 23/10/2010.
[26] GUNZER, Hartwig. Introduction to Web Services. Borland, 2002. Disponível
em <http://dn.codegear.com/article/images/28818/webservices.pdf>, acessado em
acessado em 23/10/2010.
[27] [MEDEIROS, Manoel Pimentel Web Services com Net. Revista Java Magazine.
Ed 44.
[28] Site Oficial Apache Tomcat. Disponível em <http://tomcat.apache.org/>,
acessado em 01/11/2010.
[29] Site Oficial Apache Axis. Disponível em <http://ws.apache.org/axis/>,
acessado em 01/11/2010.
[30] kSOAP Downloads. Disponível em: <http://ksoap.objectweb.org/software/
downloads/>, acessado em 01/10/2010.
[31] HÜLLER, Dênis Ricardo. Desenvolvimento de uma Interface Homem
Máquina para Aplicações em Monitoramento em Tempo Real de Sistemas
Trifásicos (Web-Based). Trabalho de Conclusão de Curso. Unijuí, 2008.
[32] LI, D; Serizawa Y; and Kiuchi M. Concept Design For a Web-Based
Supervisory Control and Data-Acquisition (SCADA) System, Transmission And
Distribution Conference And Exhibition 2002: Asia Pacific. IEEE/PES volume 1, 6-10
Oct. 2002 Page(s):32 - 36 vol.1.
[33] PADOIN, Edson Luis; SAUSEN, Paulo Sérgio; SALVADORI, Fabiano;
CAMPOS, Maurício de; DILL, Sérgio Luis; IDALENCIO, Tiago A. Mobilidade no
Monitoramento de Subestações Elétricas através de Serviços Web. In: Simpósio
de Informática da Região Centro do RS - SIRC/RS, 2007, Santa Maria. Anais do
Simpósio de Informática da Região Centro do RS, 2007. Disponível em <
http://www.sirc.unifra.br/artigos2007/artigo14.pdf>. Acessado em 04/09/2010.
[34] FACCIN, Luis Fabio; DILL, Sérgio Luis; CAMPOS, Maurício de; PADOIN, Edson
Luiz Aplicação de Software Livre, Dispositivos Móveis e Web Services no
Monitoramento Remoto de Subestações Elétricas. In: DINCON'09 - 8th Brazilian
Conference on Dynamics, Control and Applications, 2009, Bauru, SP. Anais do 8º
Congresso Brasileiro de Dinâmica, Controle e Aplicações DINCON 09, 2009.
[35] Soekris Engineering net4521. Disponível em <http://www.soekris.com/
net4521.htm>, acessado em 04/09/2010.
110
[36] DILL, Martin André Aarnold; SAUSEN, Paulo Sérgio; DILL, Sérgio Luis;
PADOIN, Edson Luiz Automação de Subestações de Energia Elétrica Utilizando
Dispositivos Móveis. DINCON'09 - 8th Brazilian Conference on Dynamics, Control
and Applications, 2009, Bauru, SP. Anais do 8º Congresso Brasileiro de Dinâmica,
Controle e Aplicações DINCON 09, 2009.
[37] J2me ChartComponent v.1.5.2. Disponível em <http://www.beanizer.org/
site/index.php/en/Software/J2me-ChartComponent-ver-1.5.html>,
acessado
em
04/09/2010.
[38] Tecnologia de Banco de Dados IBM DB2 Express-C Oferta para
Estudantes.
Disponível
em:
<http://www.ibm.com/br/university/files/
IBM_DB2_Express-C_Bundle_Final_5_20_08.doc>, em 04/09/2010.
[39] GEHRKE C. S.; Salvadori F.; Campos, M. de; Sausen, P. S.; Sponh, M. A.;
Oliveira A. C.; Camargo R. F. de; Lemos J. Power energy substation automation
based on a hybrid network architecture system. 2005.