Programação para Dispositivos Móveis com a

KATIA GOMES DA SILVA
PROGRAMAÇÃO PARA DISPOSITIVOS MÓVEIS COM A
PLATAFORMA .NET
Palmas – TO
2006
2
KATIA GOMES DA SILVA
PROGRAMAÇÃO PARA DISPOSITIVOS MÓVEIS COM A
PLATAFORMA .NET
“Trabalho de Estágio apresentado
como
requisito
parcial
da
disciplina Prática de Sistemas de
Informação I do curso de
Sistemas
de
Informação,
orientado pelo Prof. M. Sc.
Fernando Luiz de Oliveira”.
Palmas – TO
2006
3
KATIA GOMES DA SILVA
PROGRAMAÇÃO PARA DISPOSITIVOS MÓVEIS COM A
PLATAFORMA .NET
“Trabalho de Estágio apresentado
como
requisito
parcial
da
disciplina Prática de Sistemas de
Informação I do curso de
Sistemas
de
Informação,
orientado pelo Prof. M. Sc.
Fernando Luiz de Oliveira”.
BANCA EXAMINADORA
_____________________________________________
Prof. M. Sc. Fernando Luiz de Oliveira
Centro Universitário Luterano de Palmas
_____________________________________________
Profª. M. Sc. Madianita Bogo
Centro Universitário Luterano de Palmas
_____________________________________________
Prof. M. Sc. Ricardo Marx Costa Soares de Jesus
Centro Universitário Luterano de Palmas
Palmas - TO
2006
4
SUMÁRIO
1.
INTRODUÇÃO ................................................................................................ 8
2.
REVISÃO DA LITERATURA ......................................................................... 10
2.1
Dispositivos Móveis................................................................................ 10
2.1.1
Telefones Celulares Comuns.......................................................... 11
2.1.2
PDA´s ............................................................................................. 13
2.1.3
SmartPhones (Telefone Inteligente) ............................................... 13
2.2
Programação para Dispositivos Móveis ................................................. 15
2.2.1
J2ME............................................................................................... 15
2.2.2
QuickFrame .................................................................................... 15
2.2.3
.NET para Programação de Dispositivos Móveis............................ 16
2.3
Plataforma .NET .................................................................................... 17
2.3.1
Visual Studio .NET.......................................................................... 19
2.3.1.1 Emuladores..................................................................................... 19
2.3.2
2.4
Utilização de Web Services ................................................................... 22
2.5
Exemplificação da Integração das Tecnologias ..................................... 24
3.
MATERIAIS E MÉTODOS ............................................................................ 31
3.1
Local e período ...................................................................................... 31
3.2
Material .................................................................................................. 31
3.3
Metodologia ........................................................................................... 32
4.
5.
.NET Compact Framework.............................................................. 20
RESULTADOS E DISCUSSÕES .............................................................. 33
4.1
Banco de dados ..................................................................................... 34
4.2
Criação do Web Service ........................................................................ 35
4.3
Desenvolvimento da aplicação para SmartPhone ................................. 40
CONSIDERAÇÕES FINAIS .......................................................................... 44
5
LISTA DE FIGURAS
Figura 1 – Exemplos de dispositivos móveis ....................................................... 11
Figura 2 – Requisição de páginas Web através do protocolo WAP .................... 12
Figura 3 – Estrutura do .NET Framework ............................................................ 18
Figura 4 – Emulador ............................................................................................ 20
Figura 5 – Arquitetura do .NET Compact Framework.......................................... 21
Figura 6 – Ciclo de acesso ao Web Service ........................................................ 23
Figura 7 – Tela de desenvolvimento do protótipo................................................ 25
Figura 8 – Trecho do código do protótipo ContaFacil.vb ..................................... 25
Figura 9 – Código de ligação entre a aplicação e o Web Service ....................... 26
Figura 10 – Tela da execução da aplicação no emulador SmartPhone .............. 27
Figura 11 – Código do método de retorno dos dados do Web Service ............... 27
Figura 12 – Arquivo XML ................................................................................... 278
Figura 13 - Visualização do arquivo Produtos.asmx em um browser .................. 29
Figura 14 – Resultado da execução do método RetornaProdutos ...................... 30
Figura 15 – Arquitetura da aplicação................................................................... 33
Figura 16 – Modelo entidade relacionamento...................................................... 34
Figura 17 – Classe e métodos do Web Service................................................... 35
Figura 18 – WebMethod consultarPorNome........................................................ 37
Figura 19 – Visualização do arquivo Service.asmx ............................................. 38
Figura 20 – Janela para inserção do parâmetro do método consultarPorNome . 39
Figura 21 – Resultado da execução do método consultarPorNome.................... 40
Figura 22 – Tela da página inicial da aplicação................................................... 41
Figura 23 – Método de consulta por nome .......................................................... 42
Figura 24 – Código do caminho do Web Service ................................................ 42
Figura 25 – Tela do resultado da consulta por nome .......................................... 43
6
LISTA DE ABREVIATURAS
ASMX = Active Server Method Extension
CLR = Commom Language Runtime
CLS = Common Language Specidication
HTTP = Hyper Text Transfer Protocol
IL = Intermediate Language
J2ME = Java 2 Micro Edition
MSIL = Microsoft Intermediate Language
PDA = Personal Digital Assistants
SOAP = Simple Object Access Protocol
WAP = Wireless Application Protocol
WML = Wireless Makup Language
WSDL = Web Services Description Language
XML = Extensive Mark up Language
7
RESUMO
Resumo: As aplicações desenvolvidas para dispositivos móveis estão passando
por grandes transformações tecnológicas, isso se deve à necessidade de haver
comunicação em qualquer lugar e a qualquer momento. Este trabalho visa
desenvolver uma aplicação para programação de dispositivos móveis, em
especial celulares (SmartPhones), a partir de uma aplicação básica de
armazenamento, busca e acesso a base de dados, utilizando a plataforma .NET,
Web Services e a ferramenta Visual Studio.NET para o desenvolvimento da
aplicação.
Palavras-chave: Dispositivos Móveis, Plataforma .NET, Web Services.
8
1. INTRODUÇÃO
A mobilidade é o termo utilizado para identificar dispositivos que podem ser
operados à distância ou sem fio (NETTO, 2004). A particularidade que os
usuários e empresas procuram na atualidade é poder executar as tarefas a
qualquer hora e em qualquer lugar, sem a dependência de fios ou de um
computador desktop. Os usuários, por meio dos dispositivos móveis, adquirem
mobilidade e ganhos de produtividade, desempenhando suas tarefas com acesso
mais fácil e abrangente à informação. As possibilidades de uso para esses
dispositivos são inúmeras, dentre as quais, podem ser citada a programação para
jogos, para entretenimento em geral, armazenamento e busca de informações,
envio e recebimento de sons e imagens e acesso a Internet.
As tecnologias para desenvolvimento de aplicações para dispositivos
móveis oferecem recursos que permitem integrar diversos aplicativos e
plataformas, como J2ME (Java 2 Micro Edition), .NET e uma nova plataforma que
está em desenvolvimento, a QuickFrame, que se caracteriza por ser padronizada
para desenvolvimento de software para dispositivos móveis.
Um dos componentes da plataforma .NET que oferece a estrutura
necessária para o desenvolvimento de aplicações para dispositivos móveis é o
.NET Compact Framework, que acompanha o Visual Studio .NET. O Visual Studio
.NET é uma ferramenta que proporciona um ambiente de desenvolvimento
integrado em que se pode desenvolver, depurar, testar, disponibilizar Web
Services e aplicações (BASIURA et al., 2003). Além disso, oferece recursos
necessários para o desenvolvimento de aplicações móveis, tais como:
emuladores, que simulam um dispositivo móvel real e possui todos os recursos
oferecidos pelo mesmo, além de facilitar os testes durante o desenvolvimento.
9
Este trabalho tem como objetivo, estudar as facilidades oferecidas pela
plataforma .NET no desenvolvimento de aplicações para dispositivos móveis, em
especial SmartPhones. Para exemplificar estas facilidades será desenvolvida uma
aplicação
responsável
por
apresentar
o
resultado
do
vestibular
do
CEULP/ULBRA, localizado em um banco de dados remoto, o qual será acessado
por meio de métodos de um Web Service. Desta forma, será realizada a
implementação de uma aplicação de armazenamento, busca e acesso a base de
dados.
Este trabalho está estruturado em capítulos, divididos da seguinte forma: o
capítulo 2 apresenta uma visão geral sobre os dispositivos móveis, a
programação
para
estes
dispositivos,
a
ferramenta
utilizada
para
o
desenvolvimento da aplicação para os dispositivos móveis, a utilização da
plataforma .NET e seus componentes, assim como uma breve descrição de Web
Services. O capítulo 3 apresenta os materiais e métodos utilizados para o
desenvolvimento do trabalho. Já o capítulo 4 apresenta os detalhes do banco de
dados, da implementação do Web Service, do desenvolvimento da aplicação para
dispositivos
móveis
(SmartPhone)
e
os
passos
seguidos
para
seu
desenvolvimento. Em seguida, o capítulo 5 apresenta as considerações finais
sobre o trabalho. Por fim, no capítulo 6 são apresentadas as referências
bibliográficas utilizadas para o desenvolvimento deste trabalho.
10
2. REVISÃO DA LITERATURA
Para o desenvolvimento deste trabalho foram realizadas pesquisas e estudos
sobre dispositivos móveis, plataforma .NET e Web Services, a fim de fornecer
embasamento teórico sobre os mesmos. Esses estudos estão disponibilizados
nas seções seguintes.
2.1 Dispositivos Móveis
Os dispositivos móveis são ferramentas que podem ser utilizadas em qualquer
lugar que, além das funcionalidades de agenda eletrônica ou assistente pessoal,
se caracterizam por serem sistemas computadorizados que facilitam a
comunicação, através do acesso à Internet. Têm o objetivo de atender aos
usuários em movimento que necessitem de rapidez, facilidade e segurança no
acesso a informações, independentemente da sua localização física (PEKUS,
2002). São, por isso, tecnologias para a interligação de dispositivos móveis à
grande rede, possibilitando, não só o tráfego de voz, mas também o envio e
recebimento de dados, suprindo a necessidade de dispor de dados o tempo todo
e em qualquer lugar.
Estas operações são viáveis por meio de um dispositivo portátil (móvel)
como telefones móveis (celulares), diferentes tipos de PDA´s (Personal Digital
Assistants) ou os SmartPhones, que são a junção do telefone celular com
diversos atributos de um PDA (TARIFA, 2004). A Figura 1 apresenta alguns
exemplos de dispositivos móveis.
11
Figura 1 – Exemplos de dispositivos móveis
A Figura 1 apresenta alguns exemplos de dispositivos móveis, sendo dois
modelos de Pocket PC e um SmartPhone.
2.1.1 Telefones Celulares Comuns
Os telefones celulares evoluíram de simples mecanismos de comunicação por
voz para agenda eletrônica, entreterimento em geral, acesso à Internet, ou seja,
dispositivos móveis que podem ser operados em qualquer lugar e a qualquer
hora.
Os aparelhos celulares comuns não possuem a opção de download e
software de instalação, além do que foi configurado durante o processo de
fabricação. Alguns possuem apenas a opção de navegar pela Internet. A
navegação pela Internet, via celular, é realizada através da utilização de um minibrowser, embutido no aparelho, para interpretar o conteúdo das páginas
acessadas.
Para o acesso à Internet, o telefone celular necessita da tecnologia WAP
(Wireless Application Protocol), criada para visualização de páginas da Internet
em clientes simplificados, com baixa capacidade de processamento, ou seja, a
12
tecnologia WAP, consiste na transformação, adaptação e criação de conteúdos
da Internet para a visualização na tela de um celular (MSDN, 2003d). Esta
tecnologia caracteriza-se por ser um protocolo de transmissão de dados. Para
que as páginas da Internet sejam acessíveis por aparelhos celulares, é
necessário utilizar a linguagem WML (Wireless Makup Language), que é a
linguagem usada para montar as páginas acessíveis por esta tecnologia. A Figura
2 mostra como essas páginas são requisitadas a partir do protocolo WAP.
CLIENTE
CLIENTE
GATEWAYWAP
WAP
GATEWAY
1
Requisição
SERVIDOR
2
Requisição
Conversor
HTTP e TCP/IP
WML
3
Resposta
5
Resposta Conteúdo
4
SERVIDOR WEB
Figura 2 – Requisição de páginas Web através do protocolo WAP
Para oferecer páginas WML acessíveis por celulares, é necessário utilizar
um mini-browser, um recurso embutido no aparelho, que é responsável pela
visualização das páginas de Internet na tela do aparelho. A requisição da página é
feita através dos protocolos TCP/IP e HTTP (Hyper Text Transfer Protocol), que
estabelece a comunicação com a Internet. Para demonstrar passo a passo à
requisição de páginas Web por celulares, a requisição será dividida em 5 etapas,
conforme ilustrado na Figura 2: a etapa 1 representa a solicitação do cliente de
uma página da Internet; na etapa 2 o gateway recebe a requisição e converte
para o padrão HTTP/TCP/IP e envia para o servidor Web; na etapa 3 o servidor
Web recebe a solicitação e gera a página em código WML e envia para o
gateway; na etapa 4 o gateway recebe o código WML da página e, então, o
encaminha para o cliente; e, por fim, na etapa 5 a página requisitada será
visualizada pelo cliente (celular).
13
2.1.2 PDA´s
A necessidade de disponibilizar aplicações e informações em qualquer momento
e em qualquer lugar fez surgir uma linha de dispositivos móveis conhecidos como
PalmTops ou Pocket PCs. Esses dispositivos podem ser considerados uma
revolução, pois foram capazes de atingir o cotidiano das pessoas e fazer parte da
vida delas, modificando suas rotinas e decisões. Os Pockets possuem grande
quantidade de memória, telas com pontos sensíveis a toques, mouse simulado
por uma caneta (chamada de stylus), possuem modem, teclado e câmera digital
acoplada, tela colorida, rede sem fio embutida, ou seja, são computadores
pessoais portáteis que auxiliam nas atividades do dia-a-dia (MIRANDA, 2004).
Mas ainda não possuem a mesma capacidade de processamento e memória de
um computador de mesa.
2.1.3 SmartPhones (Telefone Inteligente)
Para evitar o desconforto pela necessidade de carregar um PDA e um celular,
além da necessidade de se obter maiores recursos e formas de aproveitar as
novas opções de conectividade e transmissão de dados em alta velocidade, foram
criados os SmartPhones. Estes dispositivos correspondem a um telefone celular
que possui atributos dos PDAs, com maior capacidade de memória e
processamento, recursos de expansibilidades e facilidades de acesso à Internet
(MIRANDA, 2004).
Os SmartPhones foram planejados para serem usados da mesma maneira
que um celular, porém, com os recursos técnicos disponíveis em um PDA,
reunindo a mobilidade do primeiro e a capacidade de processamento do segundo.
A Microsoft criou um conjunto de setas para facilitar a manipulação da navegação,
discagem e acesso a dados no SmartPhone (TARIFA, 2004). Apesar das
semelhanças, os SmartPhones possuem uma tela pequena, não sensível ao
toque e não suportam caneta (stylus) para simular o mouse (MIRANDA, 2004).
14
Alguns dos recursos que acompanham os SmartPhones são: o sistema
operacional Windows, Internet Explorer, Media Player e MSN Messenger. É
possível, ainda, a instalação de diversos aplicativos, além de trazer o .NET
Compact Framework já instalado. Segundo Guimarães (2004), o SmartPhone
realiza tarefas básicas que um computador é capaz de fazer, gerencia e-mails,
arquivos de texto, áudio e vídeo, tira fotos, navega em alta velocidade pela
Internet, transfere dados para outros equipamentos e possui o tamanho de um
celular comum. É um dispositivo móvel pequeno, que auxilia na realização de
tarefas enquanto seus usuários estão em movimento, proporcionando ganho de
tempo.
Porém, existem limitações computacionais devido ao tamanho destes
dispositivos, juntamente com os poucos recursos de hardware, uma vez que a
capacidade de processamento, armazenamento, memória, entre outros, são
inferiores ao de um computador convencional, ou seja, possuem arquiteturas e
tecnologias limitadas. Por isso, os mesmos não são capazes de realizar tarefas
com o mesmo desempenho de um computador, além de não ser tão prático para
atividades como: montar documentos grandes, digitar e trabalhar com recursos
visuais.
A necessidade de um sistema operacional para ser utilizado nesses
dispositivos fez surgir sistemas operacionais como: Palm OS, que oferece
segurança para o armazenamento de informações e facilita a integração de
equipamentos com o ambiente de rede (PALM OS, 2005); Symbian OS,
desenvolvido exclusivamente para dispositivos móveis (SYMBIAN, 2005);
Windows CE, versão simplificada do Windows, criada pela Microsoft, que
facilmente pode ser embutido em hardware de pequena capacidade de memória e
processamento (MICROSOFT, 2005). A Microsoft lançou uma versão especial do
Windows CE, adaptando a interface para o uso de SmartPhones, o sistema
operacional Windows Mobile (MICROSOFT, 2005).
15
2.2 Programação para Dispositivos Móveis
As aplicações desenvolvidas com a plataforma .NET, para serem executadas em
dispositivos móveis, necessitam de alguns recursos que os aparelhos celulares
comuns não possuem. Isso ocorre devido a vários fatores como, por exemplo, os
diferentes tipos de aparelhos que usam processadores e hardware diferentes.
Além de possuírem arquiteturas e tecnologias diferentes, outro fator limitante
refere-se a pouca quantidade de memória para armazenamento de dados e
programas, o que dificulta a instalação de qualquer versão do .NET em celulares
comuns (MIRANDA, 2004).
Inicialmente, para o desenvolvimento de aplicações para dispositivos
móveis, existiam apenas as linguagens derivadas do C++ e Visual Basic,
conhecidas como eVC e eVB (MIRANDA, 2004). A partir destas, surgiram outras
tecnologias para o desenvolvimento de aplicações para dispositivos móveis, como
o J2ME, que não define um novo tipo de Java, mas adapta sua plataforma para
que seja possível executar programas em dispositivos móveis (SUN, 2005); a
QuickFrame, projeto que visa padronizar uma plataforma para dispositivos móveis
(UNICAMP, 2005); e o .NET, plataforma que possui sua versão para dispositivos
móveis chamada de .NET Compact Framework (MSDN, 2003a). As seções
seguintes resumem cada uma destas tecnologias.
2.2.1 J2ME
O Java 2 Micro Edition (J2ME) é a versão do Java desenvolvida para dispositivos
móveis,
projetada
para
dispositivos
com
memória,
vídeo
e
poder
de
processamento limitado (MUCHOW, 2004). A plataforma J2ME é dividida em três
camadas: configurações, perfis e máquina virtual (SUN, 2005). São camadas
trabalhadas especialmente para serem utilizadas na programação para
dispositivos móveis.
2.2.2 QuickFrame
16
Com o objetivo de diminuir as barreiras no desenvolvimento de soluções de
mobilidade e maximizar o poder criativo do maior número possível de empresas
brasileiras de desenvolvimento de softwares, a Universidade Estadual de
Campinas (Unicamp), em parceria com a Intel, a Compera e a Universidade
Federal de Mato Grosso do Sul (UFMS), encaminharam à Financiadora de
Estudos e Projetos (Finep) um projeto para a criação de uma nova plataforma de
desenvolvimento de software para dispositivos móveis: o QuickFrame (UNICAMP,
2005). O projeto tem como principal objetivo desenvolver uma plataforma padrão
para dispositivos móveis, e está previsto para ser concluído em 2006. O objetivo
do projeto é desenvolver uma plataforma básica e estrutural de código aberto
para a criação de aplicações genéricas (FUOCO, 2005), ou seja, permitir que os
programadores escrevam apenas uma vez o software para celulares, que rode
em qualquer modelo de aparelho, independentemente da tecnologia e de
características, tal como o tamanho da tela, por exemplo.
2.2.3 .NET para Programação de Dispositivos Móveis
Para a programação de dispositivos móveis, o .NET oferece várias ferramentas
como o ASP .NET e .NET Compact Framework. Uma aplicação criada através do
ASP .NET para dispositivos móveis é semelhante à de uma aplicação ASP .NET
para páginas comuns, inclusive possuindo a mesma extensão de arquivo: ‘.aspx’
(AVELINO, 2004). O seu diferencial são os controles de servidor especializados
para dispositivos móveis, responsáveis por possibilitar que uma página ASP .NET
seja adaptada automaticamente de acordo com o dispositivo utilizado. Assim,
pode-se acessar páginas ASP .NET em dispositivos móveis (um celular, por
exemplo), ou mesmo acessá-las normalmente através do navegador Web de um
microcomputador.
Os controles de servidor, tanto para páginas ASP.NET comuns quanto
para dispositivos móveis, são praticamente os mesmos. Por exemplo, um controle
de servidor Label de uma página ASP. NET comum produz o mesmo efeito de
uma que será executada para um dispositivo móvel. Porém, internamente
possuem características diferentes, pois o controle para páginas comuns precisa
apenas mostrar saída HTML. Já o controle para dispositivos móveis precisa
17
primeiro preocupar-se com o dispositivo utilizado antes de exibir o texto solicitado,
utilizando uma linguagem também de marcação, a WML (Wireless Modeling
Language), projetada para especificar interfaces para dispositivos móveis,
levando em consideração o tamanho da tela e o mecanismo de paginação do
dispositivo (AVELINO, 2004).
Com o .NET Compact Framework (.NET CF) é possível o desenvolvimento
de aplicações para dispositivos móveis, como Pockets e SmartPhones, usando
linguagens como VB.NET, C# ou J# (NETTO, 2005), além da utilização de Web
Services. O conceito do .NET Compact Framework será apresentado nas
subseções seguintes.
2.3 Plataforma .NET
Segundo Deitel, Deitel e Nieto (2004), a plataforma .NET permite uma
independência de linguagem, plataforma e de dispositivo na implementação de
software, possibilitando ao desenvolvedor, por exemplo, a escolha da linguagem
de programação no momento da criação do aplicativo, bastando que a linguagem
seja suportada pelo .NET. Para saber se a linguagem é compatível com o .NET
existe
uma
especificação,
conhecida
como
CLS
(Common
Language
Specidication) (MSDN, 2003b), que define um conjunto de regras que as
linguagens que implementam a .NET devem seguir.
A plataforma .NET é executada sobre uma Commom Language Runtime
(CLR), responsável pela execução do programa, que é capaz de executar mais de
vinte linguagens diferentes de programação (Pascal, C++, Haskell, Java, Scheme,
C#, VB, J#, etc.), interagindo entre si, possibilitando o desenvolvimento em
multilinguagens (MSDN, 2003c). Por isso, em um mesmo projeto pode-se
desenvolver cada módulo em uma linguagem diferente.
Um dos principais elementos da plataforma .NET é o .NET Framework, que
provê os serviços e componentes necessários para o desenvolvimento e
execução de aplicações baseadas em .NET. A arquitetura do .NET Framework
consiste de alguns componentes como: CLR e .NET Framework Class Library,
como mostra a Figura 3 (MSDN, 2003b).
18
Figura 3 – Estrutura do .NET Framework
Na Figura 3, são definidos os componentes do .NET Framework. Entre eles
estão a CLR, que é um ambiente de execução, o qual dá suporte às linguagens
habilitadas. Para que uma linguagem esteja habilitada ao .NET, seu compilador
deve gerar o chamado código Microsoft Intermediate Language (MSIL), abreviado
como Intermediate Language (IL) (MSDN, 2003c). Este é o código que será
executado pela CLR, ou seja, as linguagens são compiladas para um código
intermediário denominado IL que define as instruções para o CLR, depois disso o
código IL será compilado para código de máquina, criando, assim, um aplicativo
único.
O motivo da compilação para um código intermediário deve-se a
necessidade de portabilidade entre sistemas operacionais, a interoperabilidade
entre as linguagens e os recursos de gerenciamento de execução, tornando os
programas desenvolvidos no .NET independentes de plataforma. Assim, o código,
uma vez escrito e compilado, pode ser executado em qualquer plataforma de
sistema operacional (GALVIN, 2004).
“A
interoperabilidade
de
linguagens
oferece
vários
benefícios às empresas de software. Os desenvolvedores de Visual
Basic .NET e Visual C++ .NET podem trabalhar lado a lado no mesmo
projeto sem ter que aprender uma outra linguagem de programação –
todos os seus códigos são compilados em MSIL e ligados para formar
um programa” (DEITEL, 2004).
19
Outro componente do .NET Framework é o .NET Class Library, que é uma
coleção de classes e tipos integrada com o ambiente de execução (MSDN,
2003b). Para o desenvolvimento de aplicações para dispositivos móveis utilizando
o .NET é possível utilizar um simples editor de texto, porém, para um
desenvolvimento mais completo é recomendável um ambiente mais sofisticado,
como o Visual Studio .NET, tema abordado na próxima seção.
2.3.1 Visual Studio .NET
O Visual Studio .NET facilita o desenvolvimento de aplicações para dispositivos
móveis, uma vez que permite que uma aplicação seja desenvolvida numa mesma
ferramenta, sem a preocupação com o formato do aparelho a ser utilizado, bem
como quais os recursos que o mesmo disponibilizará. Assim, a aplicação poderá
ser desenvolvida e utilizada tanto por um PDA, como por um SmartPhone.
Com o Visual Studio .NET podem-se criar páginas para Web, criar software
para Windows, ou seja, programas que serão instalados e utilizados no
computador, criar software para dispositivos móveis, utilizando as mesmas
linguagens, como VB.NET, C# ou J#, ou o desenvolvimento em multilinguagens.
Suporta, também, o desenvolvimento de Web Services, além de facilitar a
atividade de testes da aplicação, através dos emuladores disponíveis, que será
visto na seção a seguir.
2.3.1.1 Emuladores
Para que seja possível a simulação de um dispositivo móvel, é necessário instalar
um SDK (Software Development Kit) na ferramenta Visual Studio .NET,
permitindo que sejam feitos testes durante o desenvolvimento de uma aplicação
para dispositivos móveis. Um emulador de dispositivos móveis representará um
dispositivo real com todos os recursos que o mesmo possui, de acordo com o tipo
de aplicação que será desenvolvida, possibilitando, caso necessário, os ajustes
no aplicativo. Assim, quando for necessário executar uma aplicação na
20
ferramenta de desenvolvimento, pode-se escolher se será executado no
emulador, representado na Figura 4, ou em um dispositivo real que possui suporte
à plataforma .NET Compact Framework, pois a ferramenta Visual Studio .NET
disponibiliza essas opções.
Figura 4 – Emulador
A Figura 4 representa a tela principal do emulador do SmartPhone, que
serve para simular a execução de uma aplicação, não sendo necessário um
dispositivo real.
2.3.2 .NET Compact Framework
Para suprir a necessidade de uma plataforma específica para dispositivos móveis,
a Microsoft desenvolveu o .NET Compact Framework (.NET CF) (MSDN, 2003a).
O .NET CF é uma versão simplificada do .NET Framework, com um conjunto
específico de ferramentas, desenvolvido especialmente para a implementação de
aplicações em dispositivos móveis. Já que o .NET CF é um subconjunto do .NET
Framework, os desenvolvedores podem reutilizar grande parte da experiência e
conhecimento adquiridos na implementação de aplicações desktop para o
desenvolvimento de aplicações para dispositivos móveis. A arquitetura do .NET
Compact Framework é demonstrada na Figura 5 (MSDN, 2003b).
21
Figura 5 - Arquitetura do .NET Compact Framework
A Figura 5 ilustra os elementos do .NET CF. Por ser uma versão
simplificada da .NET Framework, a .NET CF possui uma nova implementação da
CLR, modificada para suportar a execução de aplicações em dispositivos móveis,
isto é, com memória, processamento e bateria limitados. A biblioteca de classes
(Class Library) do .NET CF possui menos da metade das classes da versão
completa do . NET Framework. Porém, possui todas as classes básicas do .NET
Framework, o que é suficiente para o desenvolvimento da maioria das aplicações
(MSDN, 2003b), como, por exemplo, suporte à WinForms (formulários e
controles), data binding (ligação de dados), networking (recursos de acesso à
rede LAN/WAN e suas derivações Wireless) e acesso a dados.
Um dos fatores que levaram a exclusão de algumas classes da biblioteca
do .NET Framework na versão simplificada é que as aplicações que são
computacionalmente difíceis de programar contradiz os objetivos do .NET CF:
minimizar o processo de desenvolvimento de aplicações. Por essa razão, o .NET
Compact Framework exclui funcionalidades como XML Path Language (XPath) e
Extensible Stylesheet Language Transformations (XSLT) presentes na versão
completa do .NET Framework (PEKUS, 2002).
22
O .NET CF possibilita, também, o desenvolvimento de aplicações em
multilinguagens, ou seja, em uma mesma aplicação pode-se construir cada
módulo em uma linguagem diferente, por exemplo: a classe de acesso a dados
em C# e os módulos de interface em VB.NET possibilitando a integração de
várias linguagens numa mesma plataforma (NETTO, 2005).
As aplicações desenvolvidas com o .NET CF possuem algumas
características como:
•
uma variedade expressiva de componentes visuais que são utilizados no
desenvolvimento de aplicações como, por exemplo, botões, imagens, além de
ser possível fazer uso de recursos de interface mais sofisticados, por exemplo,
animações.
•
é possível desenvolver aplicações que possuem a opção de trabalhar off-line,
ou seja, processam dados localmente sem a necessidade de uma conexão
ativa.
A plataforma .NET CF permite também o desenvolvimento de aplicações
que utilizam à tecnologia de Web Services. A utilização de um Web Service será
apresentada na próxima seção.
2.4 Utilização de Web Services
Gumz (2005) resume o Web Service como um padrão de computação distribuída,
na qual deve existir a criação, publicação, localização e acesso por sistemas
remotos. A utilização de Web Services permite a comunicação de diferentes
aplicações, podendo ser uma aplicação Web, uma aplicação Windows, ou de um
dispositivo móvel, sendo que as informações podem ser compartilhadas e
acessadas por essas aplicações, possibilitando consultas em tempo real aos
dados. Assim, um Web Service pode ser desenvolvido na plataforma .NET e ser
acessado por uma aplicação desenvolvida em outra plataforma, como a
plataforma Java, e vice-versa.
Assim, como os dispositivos móveis apresentam algumas limitações de
recursos computacionais, a utilização do Web Service é um fator importante para
o desenvolvimento das aplicações. Isto porque parte do processamento passa a
ser função de servidores remotos, uma vez que o Web Service passa a ser o
23
responsável pela conexão entre a aplicação e os dados armazenados no banco de
dados, além de proporcionar a consulta de outras aplicações aos dados
disponibilizados por meio dos serviços do Web Service, conforme mostra a Figura
6.
INTERNET
WEB SERVICES
XML
BANCO DE DADOS
CLIENTE
Figura 6 – Ciclo de acesso ao Web Service
A Figura 6 ilustra o ciclo de acesso ao Web Service, em que vários tipos de
clientes conectados à Internet podem ter acesso a diversos tipos de Web
Services, adequados para uso ou exibição no cliente que o solicitou, os quais
podem estar ligados a um banco de dados.
Para que a aplicação possa se comunicar com o Web Service, pode-se
usar a WSDL (Web Services Description Language). Esta é uma linguagem
baseada em XML (Extensive Markup Language) para a representação das
funcionalidades de um Web Service (PEREZ, 2004). Essas funcionalidades
podem ser definidas em arquivos do tipo ‘.asmx’ (Active Server Method
Extension), que descrevem exatamente como as duas partes, provedor do Web
Service e a aplicação que o utilizará, deverão se comunicar. As aplicações para
dispositivos móveis funcionam como clientes para Web Service, isto é, consomem
os serviços do Web Service, assim quando uma informação for solicitada por um
cliente (aplicação), o Web Service retornará os dados apropriados.
As
funcionalidades
de
um
Web
Service
são,
resumidamente,
fundamentadas na troca de dados e informações. Como ele é baseado no
protocolo SOAP (Simple Object Access Protocol), utilizado para o transporte de
dados e informações (SOAP, 2003), qualquer plataforma que interprete rotinas
HTTP (Hyper Text Transfer Protocol) e manipule a linguagem XML pode utilizar
24
os dados dos Web Services sem qualquer problema (PEREZ, 2004). O protocolo
SOAP proporciona ao Web Service uma independência de plataforma, linguagem
e localização. Não importa a linguagem que a aplicação foi desenvolvida, nem a
plataforma usada, assim como não importa onde o cliente está localizado, o Web
Service tem a capacidade de estabelecer conexão e compartilhar dados entre
sistemas diferentes, sem estarem ligados entre si.
A seguir será apresentado um protótipo que servirá para exemplificar
algumas das características apresentadas anteriormente, a fim de analisar o
ambiente de desenvolvimento e o modelo de programação sugerido para este
trabalho. Como ambiente de desenvolvimento do protótipo foi utilizado o Visual
Studio .NET 2005, o .NET Compact Framework, Web Service e, para a
visualização e realização dos testes, foi utilizado um emulador (SDK SmartPhone
2003), já instalado no Visual Studio.
2.5 Exemplificação da Integração das Tecnologias
Como base para o desenvolvimento de uma aplicação para dispositivos móveis,
foi usada a aplicação de nome “ContaFacil” de Tarifa (2004). A aplicação
desenvolvida é responsável por realizar uma consulta dos valores do cardápio
(menu) de um restaurante, o qual será apresentado na tela do emulador
SmartPhone, utilizando Web Service. A Figura 7 mostra a tela da aplicação sendo
desenvolvida.
25
Figura 7 – Tela de desenvolvimento do protótipo
O protótipo foi criado a partir de um arquivo chamado ContaFacil.vb, que
possui o código na linguagem VB.NET. No Visual Studio .NET, quando se inicia
uma aplicação para dispositivos móveis, um menu já está acoplado ao formulário,
como mostra a Figura 7, é necessário, apenas, definir as suas opções e
implementar seus métodos. Para esta aplicação foi criada, no menu, a opção
“Valores” que, quando selecionada, irá abrir outro formulário, onde serão
apresentados os valores que contém no menu do restaurante, conforme parte dos
códigos mostrados na Figura 8.
Private Sub menuSair_Click(ByVal sender As System.Object, ByVal e
As System.EventArgs) Handles menuSair.Click
Me.Close()
End Sub
Private Sub menuValores_Click(ByVal sender As System.Object, ByVal
e As System.EventArgs) Handles menuValores.Click
'Instancia um objeto do tipo frmValor
Dim frmNovo As New frmValor
'Chama o formulário instanciado
frmNovo.ShowDialog()
End Sub
Figura 8 – Trecho do código do protótipo ContaFacil.vb
26
Na Figura 8, o método menuValores_Click é responsável por chamar
um novo formulário, “frmValor”, que é o formulário final da aplicação. O método
menuSair_Click é responsável pelo encerramento da execução. A seguir,
após a seleção da opção “1 Valores” do menu na tela do emulador, conforme
mostrado na Figura 7, o código existente no evento Load do formulário
“frmValor” instancia a função de retorno dos dados requisitados, presente na
aplicação do Web Service, conforme indicado na Figura 9.
l Public Class frmValor
Inherits System.Windows.Forms.Form
Friend WithEvents lstProdutos As System.Windows.Forms.ListView
Friend WithEvents colProdutos As System.Windows.Forms.ColumnHeader
Friend WithEvents colValor As System.Windows.Forms.ColumnHeader
Friend WithEvents MainMenu1 As System.Windows.Forms.MainMenu
Private Sub lstProdutos_SelectedIndexChanged(ByVal sender As
System.Object, ByVal e As System.EventArgs)Handles
lstProdutos.SelectedIndexChanged
End Sub
Private Sub frmValor_Load(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles MyBase.Load
Dim i As Integer
'Instancia WS como um objeto do tipo Produtos (do WebService)
Dim WS As New Produtos.Produtos
'Declara um novo DataSet
Dim ds As New DataSet
'Carrega o DataSet com o retorno da função
ds = WS.RetornaProdutos
lstProdutos.Items.Clear()
For i = 1 To ds.Tables(0).Rows.Count - 1
Dim Item As New
ListViewItem(ds.Tables(0).Rows(i).Item(1).ToString)
Item.SubItems.Add(ds.Tables(0).Rows(i).Item(2).ToString)
lstProdutos.Items.Add(Item)
Next
End Sub
Figura 9 – Código de ligação entre a aplicação e o Web Service
A partir da execução do evento Load, o resultado da função
“RetornaProdutos” do Web Service, que será apresentado mais a frente, é
apresentado no emulador, conforme mostra a Figura 10.
27
Figura 10 – Tela da execução da aplicação no emulador SmartPhone
A Figura 10 mostra os valores que são retornados quando requisitados
pela aplicação e que são a fonte de dados do Web Service, o código responsável
pelo retorno dos dados do Web Service será apresentado na Figura 11.
Imports System.Web
Imports System.Data
Imports System.Web.Services
Imports System.Web.Services.Protocols
<WebService(Namespace:="http://tempuri.org/")> _
<WebServiceBinding(ConformsTo:=WsiProfiles.BasicProfile1_1)> _
<Global.Microsoft.VisualBasic.CompilerServices.DesignerGenerated()> _
Public Class Produtos
'Declara a classe que implementa o Web Service e seus métodos
Inherits System.Web.Services.WebService
'O método é acessado via Web devido à declaração do <WebMethod()>
<WebMethod(Description:="Consumindo WS no SmartPhone")> _
Public Function RetornaProdutos() As DataSet
'Declara um objeto DataSet
Dim ds As New DataSet
'Lê o arquivo XML criado
ds.ReadXml(Server.MapPath("Produtos.xml"))
'Retorna o ds
Return ds
End Function
End Class
Figura 11 – Código do método de retorno dos dados do Web Service
28
A Figura 11 apresenta o arquivo “Produtos.asmx”, que contém o código
do método que retorna os dados vindos do Web Service, “RetornaProdutos”,
quando
requisitados
pela
aplicação.
A
linguagem
utilizada
para
o
desenvolvimento do Web Service foi a XML (Extensive Markup Language). A
fonte
de
dados
do
Web
Service
é
um
arquivo
XML,
chamado
de
Produtos.xml. O formato do arquivo XML utilizado será apresentado na Figura
12.
<?xml version="1.0" encoding="utf-8" ?>
<Produtos>
<Produto>
<Codigo>1</Codigo>
<Nome>Lasanha</Nome>
<Valor>20,00</Valor>
</Produto>
<Produto>
<Codigo>2</Codigo>
<Nome>Pizza</Nome>
<Valor>15,00</Valor>
</Produto>
<Produto>
<Codigo>3</Codigo>
<Nome>Rodízio</Nome>
<Valor>11,00</Valor>
</Produto>
<Produto>
<Codigo>4</Codigo>
<Nome>Sobremesa</Nome>
<Valor>5,00</Valor>
</Produto>
</Produtos>
Figura 12 – Arquivo XML
A Figura 12 mostra o arquivo XML contendo os dados que serão
apresentados quando requisitados pelo método do Web Service.
A visualização do Web Service pode ser feita através do navegador da
Internet (browser). A visualização do arquivo que representa as funcionalidades
do Web Service é um arquivo do tipo “.asmx”, representado na Figura 13.
29
Figura 13 - Visualização do arquivo Produtos.asmx em um browser
Na Figura 13 é possível notar a classe criada Produtos, que possui o
método RetornaProdutos. A execução do método será visto na Figura
14.
30
Figura 14 – Resultado da execução do método RetornaProdutos
A Figura 14 apresenta a execução do método que retorna os valores
requisitados, obtidos a partir dos dados de um arquivo XML.
31
3. MATERIAIS E MÉTODOS
Neste capítulo serão apresentados os detalhes referentes aos materiais e
metodologia utilizados no processo de desenvolvimento deste trabalho.
3.1 Local e período
O trabalho foi desenvolvido como requisito parcial da disciplina de Prática em
Sistemas de Informação I, do curso de Sistemas de Informação do Centro
Universitário Luterano de Palmas, no primeiro semestre de 2006 e foi
desenvolvido no laboratório do Programa Gerador de Novos Referenciais
Tecnológicos para a Região Norte - GENORTE. As atividades relacionadas a este
trabalho tiveram início no mês de janeiro de 2006 e término em julho de 2006.
3.2 Material
Os materiais utilizados podem ser divididos em três categorias: hardware,
software e fontes bibliográficas. A primeira é constituída por um notebook com
processador Intel inside Celeron M, com clock de 1.4 Ghz, 512 Mb de memória
RAM e HD com 60 Gb, responsável pelo armazenamento dos dados, criação e
execução da aplicação.
Os softwares utilizados foram os seguintes:
•
Microsoft Wod 2003;
•
Microsoft SQL Server;
•
Microsoft .NET Framework 1.1;
32
•
Microsoft .NET Framework SDK v2.0;
•
Microsoft Visual Studio 2005 Beta 2, para construção da aplicação para
dispositivos móveis, para a criação do Web Service, além da execução de
testes utilizando-se o emulador por ele provido;
•
Microsoft ActiveSync 4.0;
•
Adobe Acrobat Reader, para a leitura de referências bibliográficas.
Todo material bibliográfico utilizado pode ser observado no capítulo 6 Referências Bibliográficas.
3.3 Metodologia
A metodologia utilizada para o desenvolvimento da aplicação para dispositivos
móveis iniciou-se com um estudo teórico sobre programação para dispositivos
móveis, a plataforma .NET Compact Framework e a utilização de Web Services.
Três etapas foram utilizadas para a finalização desse trabalho: a criação do banco
de dados, a criação do Web Service e o desenvolvimento da aplicação para
dispositivos móveis.
O banco de dados para o armazenamento das informações foi criado no
Microsoft SQL Server. Em seguida, foi criado o Web Service para o acesso aos
dados armazenados no banco de dados. No Web Service foram criados métodos
de consultas para verificar o resultado do vestibular do CEULP/ULBRA. Por fim,
foi desenvolvida a aplicação para dispositivos móveis (SmartPhone), responsável
por fazer o acesso ao Web Service que buscará os dados e os retornará para a
aplicação, que, posteriormente, irá gerar o código resultante para ser visualizado
no SmartPhone.
33
4. RESULTADOS E DISCUSSÕES
O objetivo deste capítulo é apresentar alguns dos resultados obtidos com a
prática da criação da aplicação .NET Compact Framework para dispositivos
móveis a partir dos estudos realizados anteriormente. Dentre eles, a criação de
Web Service, a criação da aplicação para SmartPhone, utilizando a ferramenta
Visual Studio .NET, seus elementos e sua implementação, com o objetivo de
demonstrar a integração destas tecnologias.
A aplicação desenvolvida para este trabalho poderá enviar ou buscar
informações utilizando os serviços de um Web Service, implementado utilizando a
ferramenta Visual Studio.NET e a linguagem C#, o qual é o responsável por
realizar a conexão entre o banco de dados e a aplicação, promovendo uma
distribuição do processamento. Esta aplicação visa oferecer uma forma alternativa
para que os alunos que tenham participado do vestibular do CEULP-ULBRA
possam acessar o resultado através de um dispositivo móvel (SmartPhone). A
arquitetura desta aplicação pode ser visualizada resumidamente na Figura 15.
Figura 15 – Arquitetura da aplicação
34
Para o armazenamento dos dados será utilizado o SGBD SQL Server que
se integra ao .NET Compact Framework (MICROSOFT, 2005). Para o acesso a
esses dados será usado um Web Service, que será o centralizador da regra de
consulta da aplicação. Para a interface com o usuário será criada uma aplicação
que roda no próprio celular. Para isso, será usado um emulador do dispositivo
móvel do tipo SmartPhone.
4.1 Banco de dados
Para a organização dos dados referentes ao candidato, curso e o resultado foram
utilizados quatro tabelas, com os campos necessários para a realização da
consulta ao resultado do vestibular, armazenadas em um banco de dados SQL
Server. O modelo de entidade relacionamento deste trabalho é apresentado na
Figura 16.
Figura 16 – Modelo entidade relacionamento
A tabela tblCandidato é responsável pelo armazenamento das
informações principais do candidato. A tabela tblCurso armazena as
informações
sobre
os
cursos
representados
pelos
campos
idCurso,
35
nomeCurso e periodo. Já a tabela tblResultado armazena informações
referentes ao resultado do vestibular, através dos campos idResultado,
idCandidato, nota, situacao. E, para o relacionamento entre as tabelas
e
tblCandidato
tblCurso,
foi
criada
a
tabela
auxiliar
tblCandidato_Curso que utiliza-se como chaves estrangeiras os campos
idCurso e idCandidato. O acesso a este banco de dados será realizado
por um Web Service, o qual será apresentado na seção a seguir.
4.2 Criação do Web Service
Para o desenvolvimento do Web Service foi criada uma aplicação ASP.NET Web
Service, utilizando a linguagem C#, na qual foram criados os métodos da consulta
da classe Service, conforme ilustrado no diagrama da Figura 17.
Figura 17 – Classe e métodos do Web Service
O cliente que irá consumir os serviços do Web Service, deverá acessá-lo
através do caminho “http://localhost/WSSeguro/Service.asmx”, instalado na
máquina de origem do desenvolvimento. O Web Service criado possui dois
métodos de consulta:
•
consultarCursos: método que retorna todos os cursos cadastrados no
banco de dados, informando apenas o idCurso.
36
•
consultarPorNome: método que retorna os nomes dos candidatos
aprovados ou suplentes do vestibular, onde a consulta é realizada através
do nome passado como parâmetro. Os resultados apresentados retornam
os valores do campo nomeCandidato da tabela tblCandidato em
forma de uma lista, onde será detalhada e apresentará a situação
(aprovado/suplente), retornando os valores do campo situacao
da
tabela tblResultado.
•
consultarPorNumero: método que retorna a nota, a situação
(aprovado/reprovado) e a classificação dos candidatos, em que a consulta
é realizada por meio do número de inscrição passado como parâmetro. A
consulta retorna os valores dos campos nota e situacao da tabela
tblResultado, além da sua classificação.
O método consultarPorNome é apresentado na Figura 18. O outro
método de consulta, consultarPorNumero, segue estrutura semelhante,
alterando-se somente a string para a consulta, pois o objetivo desse método é
que apenas os usuários que possuam o número de inscrição no vestibular
possam fazer uso desta funcionalidade. Já o método consultarCursos, é
responsável por preencher uma lista dos cursos presentes no formulário de
consulta por nome.
37
1. [WebMethod(Description=”Retorna uma lista com os nomes dos
candidatos, o curso e a sua situação (ap/sup))]
2.
public DataSet consultarPorNome(string nomeCandidato, int idCurso){
3.
SqlConnection conn = new SqlConnection(STRING_DE_CONEXAO);
4.
try
5.
{
6.
conn.Open();
7.
}
8.
catch (SqlException ex)
9.
{
10.
throw new Exception("Ocorreu um erro ao abrir o banco de
dados, a descrição do erro é" + ex.Message);
11.
}
12.
SqlCommand command = new SqlCommand("SELECT * from vwNome
where nomeCandidato like '" + nomeCandidato + "%' and
idCurso= " + idCurso, conn);
13.
SqlDataAdapter adap = new SqlDataAdapter(command);
14.
DataSet dataset = new DataSet();
15.
adap.Fill(dataset, "Candidato");
16.
return dataset;
17.
}
Figura 18 – WebMethod consultarPorNome
A linha 1 especifica que o método trata-se de um WebMethod, cuja
descrição está explicitada. A linha 3 cria o objeto do tipo SqlConnection para
conexão com o banco de dados. A linha 6 abre a conexão com o banco. A linha
10 dispara uma exceção para a aplicação que está consumindo o Web Service. A
linha 12 cria o objeto do tipo SqlCommand configurando a SELECT que será
usada para retornar os dados do banco de dados criados por uma view. A linha
13 cria o objeto do tipo SqlDataAdapter que fará o preenchimento do
DataSet. A linha 14 cria o DataSet para retorno dos dados. A linha 15
preenche o DataSet com os dados do candidato. E, por fim, a linha 16 retorna
os dados para a aplicação consumidora.
A execução do Web Service é feita através do navegador de Internet, a
partir do arquivo Service.asmx, que representa as funcionalidades do Web
Service. O resultado é demonstrado na Figura 19.
38
Figura 19 – Visualização do arquivo Service.asmx
Na Figura 19, nota-se os métodos de consulta que foram criados,
chamados
consultarCursos,
consultarPorNome
e
consultarPorNumero. É possível acessá-los clicando sobre o link do método.
Após isso, uma nova janela é aberta onde irá requerer os valores passados como
parâmetro para a execução do método. A Figura 20 irá demonstrar esta janela
para inserção do valor para execução do método consultarPorNome.
39
Figura 20 – Janela para inserção do parâmetro do método
consultarPorNome
Após a inserção dos valores, pode-se invocar o método clicando no botão
Invoke. O resultado da execução do método é retornado em XML, conforme
apresentado na Figura 21.
40
Figura 21 – Resultado da execução do método consultarPorNome
A
Figura
21
consultarPorNome
mostra
para
o
a
resultado
qual
da
foram
execução
do
método
retornados
os
dados:
nomeCandidato e situacao, do curso especificado através do código de
identificação. Todos os métodos estão centralizados na classe Service.asmx,
cujo código completo está disponível na seção de anexos.
Visto o correto funcionamento do Web Service através do navegador de
Internet, a próxima seção apresentará a criação da aplicação que irá ser
executada no SmartPhone, assim como a sua conexão com o Web Service.
4.3 Desenvolvimento da aplicação para SmartPhone
A aplicação desenvolvida para rodar no SmartPhone consiste em três formulários:
o primeiro é o formulário inicial, frmInicial, ou seja, é a página principal que é
responsável pela escolha da consulta. O formulário frmNome, é responsável por
exibir os nomes dos candidatos aprovados e/ou suplentes e o nome do curso; e o
41
formulário frmNumero exibe a colocação do candidato, sua nota e sua situação
(aprovado, reprovado ou suplente), dado seu número de inscrição.
O frmInicial dispõe de um menu com as opções para a escolha do
tipo de consulta que o usuário deseja realizar e outro que encerra a execução,
conforme ilustrado na Figura 22.
Figura 22 – Tela da página inicial da aplicação
O menu “Opções” apresenta dois tipos de consulta (Nome ou Número) e,
após a escolha de uma das opções pelo usuário, outro formulário é apresentado.
A outra opção do menu refere-se a opção “Sair”, que tem a função de encerrar a
execução. Assim, o código desse formulário é formado basicamente pela
implementação das funções do menu.
Após o usuário definir o tipo de consulta, é invocado o método do Web
Service correspondente à solicitação, onde as informações são recuperadas do
banco de dados. Por exemplo, se a consulta for pelo nome, o método executado
será o consultarPorNome do Web Service, sendo que os dados retornados
42
são carregados no ListView, disposto no formulário frmNome. O método que
implementa essa consulta é apresentado na Figura 23.
1. public frmNome()
2. {
3. InitializeComponent();
4. objVestibular = new Vestibular.Service();
5. DataSet ds = objVestibular.consultarCursos();
6. cmbCurso.Items.Clear();
...
8. private void menuConsultar_Click_1(object sender, EventArgs e)
9. {
10. DataSet ds = objVestibular.consultarPorNome(txtNome.Text,
Convert.ToInt32(cmbCurso.SelectedValue));
11.
listView1.Items.Clear();
12. for (int i = 0; (i <= (ds.Tables[0].Rows.Count - 1)); i++)
13. {
14.
ListViewItem Item = new
ListViewItem(ds.Tables[0].Rows[i].ItemArray[1].ToString());
15.
Item.SubItems.Add(ds.Tables[0].Rows[i].ItemArray[2].ToString());
16.
listView1.Items.Add(Item);
17. }
18. }
19.}
Figura 23 – Método de consulta por nome
A linha 4 mostra a criação do objeto que irá receber o Web Service. Na
linha 5, é executado o método do Web Service, consultarCursos. Na linha
10,
é
apresentado
consultarPorNome,
a
execução
passando
do
como
método
parâmetro
do
o
Web
valor
do
Service,
campo
nomeCandidato e a opção selecionada do curso, o resultado da execução é
armazenado em um objeto. Entre as linhas 12 e 17, o método do Web Service é
invocado e se o objeto contendo o resultado não for nulo, seus itens são
adicionados no ListView com os dados correspondentes as colunas.
Para o acesso ao Web Service foi criada uma variável chamada “Url”, na
classe “Reference.cs”, que recebe o caminho do Web Service, conforme
mostra a Figura 24. O código completo está disponível na seção de anexos,
public Service()
{
this.Url = "http://localhost/WSSeguro/Service.asmx";
}
Figura 24 – Código do caminho do Web Service
43
O resultado da consulta por nome é apresentado na tela do emulador,
conforme mostra a Figura 25.
Figura 25 – Tela do resultado da consulta por nome
Após o desenvolvimento deste trabalho, incluindo a criação do banco de
dados, a criação do Web Service e a própria aplicação para SmartPhone, bem
como o embasamento teórico para o seu desenvolvimento, serão apresentadas
no próximo capítulo as considerações finais obtidas a partir deste trabalho.
44
5. CONSIDERAÇÕES FINAIS
A plataforma .NET oferece toda a tecnologia e as ferramentas necessárias para a
construção, implementação e manutenção de aplicações para dispositivos
móveis. A integração com o Visual Studio .NET garante aos desenvolvedores o
uso de recursos de expansibilidade para se iniciar o desenvolvimento dessas
aplicações, tais como templates, emuladores, controles, unificando todo o
ambiente de desenvolvimento em uma única ferramenta.
O Web Service surge como uma nova solução para a implementação de
aplicações acessadas via Internet, possibilitando que aplicativos de qualquer tipo,
que tenha acesso à Internet se conectem e interoperem entre si.
A computação móvel torna-se viável não somente para o segmento
empresarial, mas também para as pessoas de uma forma geral, permitindo
acesso aos dados e informações a qualquer hora e em qualquer lugar. Isso facilita
as tarefas particulares e é também uma oportunidade de melhora na gestão de
negócios, além de se promover uma forma alternativa para o atendimento ao
cliente, estabelecendo muitas opções de interatividade com o mesmo.
A partir deste estudo, verificou-se a viabilidade de desenvolver uma
aplicação para dispositivos móveis, em especial celulares (SmartPhones), os
quais são bastante semelhante ao desenvolvimento de aplicações tradicionais
para desktop, a partir de uma aplicação de armazenamento, busca e acesso a
base de dados. Deve-se levar em consideração, no desenvolvimento da
aplicação, a facilidade que o usuário deverá ter em utilizar essa aplicação,
prevendo as ações tomadas pelo usuário, sempre criando formas de navegações
simples e diretas, levando em consideração os espaços reduzidos da tela.
45
REFERÊNCIAS BIBLIOGRÁFICAS
(AVELINO, 2004) AVELINO, Jones. Consumindo um WebService através de
uma Aplicação ASP.NET para Dispositivos Móveis. 2004. Disponível em:
<http://www.linhadecodigo.com.br>
(BASIURA et al., 2003) BASIURA, Russ et al. Profissional ASP .NET Web
Service. São Paulo: Pearson Education, 2003.
(DEITEL E NIETO, 2004) DEITEL, H. M.; DEITEL, P. J.; NIETO, T. R.. Visual
Basic .NET: como programar. Tradução Célia Yumi Okano Taniwaki. São Paulo:
Pearson Education do Brasil, 2004. 1088 p.
(FUOCO, 2005) FUOCO, Taís. Padrão para dispositivos móveis. UNICAMP,
fevereiro de 2005. Disponível em: <http://www.cgi.unicamp.br>.
(GALVIN, 2004), GALVIN, Deleon. Protótipo de sistema CRM para dispositivos
móveis utilizando a tecnologia .NET. Trabalho de Conclusão de Curso
(Bacharelado em Ciências da Computação), Universidade Regional de Blumenal,
Blumenal, 2004.
(GUIMARÃES, 2004) GUIMARÃES, Camila. As empresas detectam vantagens
no
celular
que
é
também
<http://www.netmarkt.com.br>
computador.
2004.
Disponível
em:
46
(GUMZ, 2005) GUMZ, Rafael Araújo. Protótipo de um sistema gerador de
interfaces gráficas para testes de Java Web Services. 2005. 98 f. Monografia
de Pós-Graduação (Pós-Graduação em Desenvolvimento de Aplicações para
WEB) - Centro de Ciências Exatas e Naturais, Universidade Regional de
Blumenau, Blumenau.
(MICROSOFT, 2005) Microsoft SQL Server. Outubro de 2005. Disponível em:
<http://www.microsoft.com.br>
(MIRANDA, 2004) MIRANDA, Luiz Henrique. Introdução ao mundo móvel.
Maio de 2004. Disponível em: <http://www.devgoiania.NET>
(MSDN, 2003) MSDN – Tecnologias: Mobilidade. Fevereiro, 2003a.
___________.
.NET Framework. Fevereiro, 2003b.
___________.
Microsoft .NET, apresentando C#. Novembro, 2003c.
___________.
WAP:
Arquitetura.
Dezembro,
2003d.
Disponível
em:
<http://www.msdn.com.br>
(MUCHOW, 2004) MUCHOW, John W. Core J2ME: Tecnologia & MIDP.
Tradução: João Eduardo N. Tortello. São Paulo: Pearson Makron Books, 2004.
(NETTO, 2004) NETTO, Max Mosimann. Mobilidade e Dispositivos Móveis.
2004. Disponível em: <http://www.linhadecodigo.com.br>
(NETTO, 2005) NETTO, Max Mosimann. Microsoft .NET Compact Framework Conheça a plataforma para dispositivos móveis criada pela Microsoft. Março
de 2005. Disponível em: < http://www.imasters.com.br/ >
47
(PALM OS, 2005) Palm Software and Palm OS. Outubro de 2005. Disponível
em: <http://www.palmsource.com>
(PEKUS, 2002) PEKUS, Cons. e Desenvolvimento LTDA. Dispositivos Móveis.
2002. Disponível em: <http://www.pekus.com.br>
(PEREZ, 2004) PEREZ, Rogério L. G.. Visão geral sobre WebServices. 2004.
Disponível em: < http://www.imasters.com.br/ >
(SYMBIAN, 2005) Symbian OS – the mobile operating system. Outubro de
2005. Disponível em: <http://www.symbian.com>
(SOAP, 2003) SOAP Version 1.2 Part 0: Primer. Novembro de 2005. Disponível
em: <http://www.w3.org/TR/SOAP>
(SUN,
2005)
Sun
Microsystems.
Outubro
de
2005.
Disponível
em:
<http://br.sun.com>
(TARIFA,
aplicações
2004)
para
TARIFA,
Alexandre
SmartPhones.
Fernandes
Novembro
de
Chaud.
2004.
Desenvolvendo
Disponível
em:
<http://www.codificando.net>
(UNICAMP, 2005) Portal Unicamp. Outubro de 2005. Disponível em:
<http://www.unicamp.br>
48
ANEXO A
Código do Web Service criado – Service.asmx
49
<%@ WebService Language="C#" CodeBehind="~/App_Code/Service.cs"
Class="Service" %>
using
using
using
using
using
using
System;
System.Web;
System.Web.Services;
System.Web.Services.Protocols;
System.Data.SqlClient;
System.Data;
[WebService(Namespace = "http://tempuri.org/")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
public class Service : System.Web.Services.WebService
{
public const string STRING_DE_CONEXAO =
"Server=KATIA;Database=smartphone;User
ID=sa;Password=1234;Trusted_Connection=False";
public Service () {
//Uncomment the following line if using designed components
//InitializeComponent();
}
[WebMethod]
public DataSet consultarPorNome(string nomeCandidato, int idCurso) {
//cria o objeto do tipo SqlConnection para conexão com o banco de
dados
SqlConnection conn = new SqlConnection(STRING_DE_CONEXAO);
try
{
//abre a conexão com o banco
conn.Open();
}
catch (SqlException ex)
{
//dispara uma exceção para a aplicação que está
//consumindo o Web Service
throw new Exception("Ocorreu um erro ao abrir o
banco de dados, a descrição do erro é" + ex.Message);
}
//cria o objeto do tipo SqlCommand configurando a
SELECT que será usada
//para retornar os dados do banco de dados criados por
uma view
SqlCommand command = new SqlCommand("SELECT * from vwNome
where nomeCandidato like '" + nomeCandidato + "%' and idCurso= " +
idCurso, conn);
//cria o objeto do tipo SqlDataAdapter que fará o
preenchimento do DataSet
SqlDataAdapter adap = new SqlDataAdapter(command);
//cria o DataSet para retorno dos dados
50
DataSet dataset = new DataSet();
//preenche o DataSet com os dados do candidato
adap.Fill(dataset, "Candidato");
//retorna os dados para a aplicação consumidora
return dataset;
}
[WebMethod]
public DataSet consultarPorNumero(string idCandidato)
{
//cria o objeto do tipo SqlConnection para conexão com o banco de
dados
SqlConnection conn = new SqlConnection(STRING_DE_CONEXAO);
try
{
//abre a conexão com o banco
conn.Open();
}
catch (SqlException ex)
{
//dispara uma exceção para a aplicação que está
//consumindo o Web Service
throw new Exception("Ocorreu um erro ao abrir o banco de
dados, a descrição do erro é" + ex.Message);
}
//cria o objeto do tipo SqlCommand configurando a SELECT que será
usada
//para retornar os dados do banco de dados
SqlCommand command = new SqlCommand("SELECT * FROM
[smartphone].[dbo].[fn_GetPosicao]("+idCandidato+") where idCandidato='"
+ idCandidato + "'", conn);
//cria o objeto do tipo SqlDataAdapter que fará o preenchimento
do DataSet
SqlDataAdapter adap = new SqlDataAdapter(command);
//cria o DataSet para retorno dos dados
DataSet dataset = new DataSet();
//preenche o DataSet com os dados do candidato
adap.Fill(dataset, "Candidato");
//retorna os dados para a aplicação consumidora
return dataset;
}
[WebMethod]
public DataSet consultarCursos()
{
//cria o objeto do tipo SqlConnection para conexão com o banco de
dados
SqlConnection conn = new SqlConnection(STRING_DE_CONEXAO);
try
{
//abre a conexão com o banco
51
conn.Open();
}
catch (SqlException ex)
{
//dispara uma exceção para a aplicação que está
//consumindo o Web Service
throw new Exception("Ocorreu um erro ao abrir o banco de
dados, a descrição do erro é" + ex.Message);
}
//cria o objeto do tipo SqlCommand configurando a SELECT que será
usada
//para retornar os dados do banco de dados criados por uma view
SqlCommand command = new SqlCommand("SELECT * from tblCurso order
by nomeCurso", conn);
//cria o objeto do tipo SqlDataAdapter que fará o preenchimento
do DataSet
SqlDataAdapter adap = new SqlDataAdapter(command);
//cria o DataSet para retorno dos dados
DataSet dataset = new DataSet();
//preenche o DataSet com os dados do candidato
adap.Fill(dataset, "Curso");
//retorna os dados para a aplicação consumidora
return dataset;
}
}
52
ANEXO B
Código da aplicação SmartPhone com a plataforma .NET Compact Framework
frmInicial, frmNome e frmNumero
53
frmInicial.cs:
#region Using directives
using
using
using
using
using
System;
System.Drawing;
System.Collections;
System.Windows.Forms;
System.Data;
#endregion
namespace sPhone
{
/// <summary>
/// Summary description for form.
/// </summary>
public class frmInicial : System.Windows.Forms.Form
{
private PictureBox pictureBox1;
protected internal PictureBox pictureBox2;
private MenuItem menuSair;
private MenuItem menuItem2;
private MenuItem menuNome;
private MenuItem menuNumero;
/// <summary>
/// Main menu for the form.
/// </summary>
private System.Windows.Forms.MainMenu mainMenu1;
public frmInicial()
{
InitializeComponent();
}
/// <summary>
/// Clean up any resources being used.
/// </summary>
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
}
#region Windows Form Designer generated code
/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
private void InitializeComponent()
{
System.ComponentModel.ComponentResourceManager resources =
new System.ComponentModel.ComponentResourceManager(typeof(frmInicial));
this.mainMenu1 = new System.Windows.Forms.MainMenu();
this.menuSair = new System.Windows.Forms.MenuItem();
this.menuItem2 = new System.Windows.Forms.MenuItem();
this.menuNome = new System.Windows.Forms.MenuItem();
this.menuNumero = new System.Windows.Forms.MenuItem();
54
this.pictureBox1 = new System.Windows.Forms.PictureBox();
this.pictureBox2 = new System.Windows.Forms.PictureBox();
//
// mainMenu1
//
this.mainMenu1.MenuItems.Add(this.menuSair);
this.mainMenu1.MenuItems.Add(this.menuItem2);
//
// menuSair
//
this.menuSair.Text = "Sair";
this.menuSair.Click += new
System.EventHandler(this.menuSair_Click);
//
// menuItem2
//
this.menuItem2.MenuItems.Add(this.menuNome);
this.menuItem2.MenuItems.Add(this.menuNumero);
this.menuItem2.Text = "Opções";
//
// menuNome
//
this.menuNome.Text = "Consulta Nome";
this.menuNome.Click += new
System.EventHandler(this.menuNome_Click_1);
//
// menuNumero
//
this.menuNumero.Text = "Consulta Número";
this.menuNumero.Click += new
System.EventHandler(this.menuNumero_Click_1);
//
// pictureBox1
//
this.pictureBox1.Location = new System.Drawing.Point(0, 0);
this.pictureBox1.Size = new System.Drawing.Size(100, 100);
//
// pictureBox2
//
this.pictureBox2.Image =
((System.Drawing.Image)(resources.GetObject("pictureBox2.Image")));
this.pictureBox2.Location = new System.Drawing.Point(49, 42);
this.pictureBox2.Size = new System.Drawing.Size(76, 78);
//
// frmInicial
//
this.ClientSize = new System.Drawing.Size(176, 180);
this.Controls.Add(this.pictureBox2);
this.Menu = this.mainMenu1;
this.Text = "Resultado Vestibular";
}
#endregion
/// <summary>
/// The main entry point for the application.
/// </summary>
static void Main()
{
55
Application.Run(new frmInicial());
}
private void menuSair_Click(object sender, EventArgs e)
{
this.Close();
}
private void menuNome_Click_1(object sender, EventArgs e)
{
// Instancia um objeto do tipo frmNome
frmNome frmNovo = new frmNome();
// Chama o formulário instanciado
frmNovo.ShowDialog();
}
private void menuNumero_Click_1(object sender, EventArgs e)
{
// Instancia um objeto do tipo frmNumero
frmNumero frmNovo = new frmNumero();
// Chama o formulário instanciado
frmNovo.ShowDialog();
}
}
}
56
frmNome.cs:
#region Using directives
using
using
using
using
using
System;
System.Drawing;
System.Collections;
System.Windows.Forms;
System.Data;
#endregion
namespace sPhone
{
/// <summary>
/// Summary description for Nome.
/// </summary>
public class frmNome : System.Windows.Forms.Form
{
private Label label1;
private TextBox txtNome;
private MenuItem menuVoltar;
private MenuItem menuConsultar;
private Vestibular.Service objVestibular;
private Label label2;
private ComboBox cmbCurso;
private ListView listView1;
/// <summary>
/// Main menu for the form.
/// </summary>
private System.Windows.Forms.MainMenu mainMenu1;
public frmNome()
{
InitializeComponent();
objVestibular = new Vestibular.Service();
DataSet ds = objVestibular.consultarCursos();
cmbCurso.Items.Clear();
for (int i = 0; (i <= (ds.Tables[0].Rows.Count - 1)); i++)
{
ListViewItem Item = new
ListViewItem(ds.Tables[0].Rows[i].ItemArray[1].ToString());
Item.SubItems.Add(ds.Tables[0].Rows[i].ItemArray[2].ToString());
cmbCurso.Items.Add(Item);
}
}
/// <summary>
/// Clean up any resources being used.
/// </summary>
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
57
}
#region Windows Form Designer generated code
/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
private void InitializeComponent()
{
this.listView1 = new System.Windows.Forms.ListView();
this.mainMenu1 = new System.Windows.Forms.MainMenu();
this.menuVoltar = new System.Windows.Forms.MenuItem();
this.menuConsultar = new System.Windows.Forms.MenuItem();
this.label1 = new System.Windows.Forms.Label();
this.txtNome = new System.Windows.Forms.TextBox();
this.label2 = new System.Windows.Forms.Label();
this.cmbCurso = new System.Windows.Forms.ComboBox();
//
// listView1
//
this.listView1.Location = new System.Drawing.Point(0, 100);
this.listView1.Size = new System.Drawing.Size(173, 79);
//
// mainMenu1
//
this.mainMenu1.MenuItems.Add(this.menuVoltar);
this.mainMenu1.MenuItems.Add(this.menuConsultar);
//
// menuVoltar
//
this.menuVoltar.Text = "Voltar";
this.menuVoltar.Click += new
System.EventHandler(this.menuVoltar_Click_1);
//
// menuConsultar
//
this.menuConsultar.Text = "Consultar";
this.menuConsultar.Click += new
System.EventHandler(this.menuConsultar_Click_1);
//
// label1
//
this.label1.Font = new System.Drawing.Font("Nina", 10F,
System.Drawing.FontStyle.Bold);
this.label1.Location = new System.Drawing.Point(0, 0);
this.label1.Size = new System.Drawing.Size(54, 16);
this.label1.Text = "Nome:";
//
// txtNome
//
this.txtNome.Font = new System.Drawing.Font("Nina", 10F,
System.Drawing.FontStyle.Regular);
this.txtNome.Location = new System.Drawing.Point(0, 19);
this.txtNome.Size = new System.Drawing.Size(173, 23);
//
// label2
//
this.label2.Font = new System.Drawing.Font("Nina", 10F,
System.Drawing.FontStyle.Bold);
58
this.label2.Location = new System.Drawing.Point(0, 47);
this.label2.Size = new System.Drawing.Size(173, 21);
this.label2.Text = "Selecione o Curso:";
this.label2.ParentChanged += new
System.EventHandler(this.label2_ParentChanged);
//
// cmbCurso
//
this.cmbCurso.Font = new System.Drawing.Font("Nina", 10F,
System.Drawing.FontStyle.Regular);
this.cmbCurso.Location = new System.Drawing.Point(0, 71);
this.cmbCurso.Size = new System.Drawing.Size(173, 23);
this.cmbCurso.SelectedIndexChanged += new
System.EventHandler(this.cmbCurso_SelectedIndexChanged);
//
// frmNome
//
this.ClientSize = new System.Drawing.Size(176, 180);
this.Controls.Add(this.label1);
this.Controls.Add(this.txtNome);
this.Controls.Add(this.label2);
this.Controls.Add(this.cmbCurso);
this.Controls.Add(this.listView1);
this.Menu = this.mainMenu1;
this.Text = "Consulta Nome";
}
#endregion
private void menuConsultar_Click_1(object sender, EventArgs e)
{
DataSet ds = objVestibular.consultarPorNome(txtNome.Text,
Convert.ToInt32(cmbCurso.SelectedValue));
listView1.Items.Clear();
for (int i = 0; (i <= (ds.Tables[0].Rows.Count - 1)); i++)
{
ListViewItem Item = new
ListViewItem(ds.Tables[0].Rows[i].ItemArray[1].ToString());
Item.SubItems.Add(ds.Tables[0].Rows[i].ItemArray[2].ToString());
listView1.Items.Add(Item);
}
}
private void menuVoltar_Click_1(object sender, EventArgs e)
{
// Instancia um objeto do tipo frmInicial
frmInicial frmNovo = new frmInicial();
// Chama o formulário instanciado
frmNovo.ShowDialog();
}
}
}
59
frmNumero.cs:
#region Using directives
using
using
using
using
using
System;
System.Drawing;
System.Collections;
System.Windows.Forms;
System.Data;
#endregion
namespace sPhone
{
/// <summary>
/// Summary description for frmNumero.
/// </summary>
public class frmNumero : System.Windows.Forms.Form
{
private MenuItem menuVoltar;
private MenuItem menuConsultar;
private TextBox txtNumero;
private Label label1;
private Label label2;
private TextBox txtSituacao;
private Label label3;
private Label label4;
private TextBox txtNota;
private TextBox txtClassificacao;
private Vestibular.Service objVestibular;
/// <summary>
/// Main menu for the form.
/// </summary>
private System.Windows.Forms.MainMenu mainMenu1;
public frmNumero()
{
InitializeComponent();
objVestibular = new Vestibular.Service();
}
/// <summary>
/// Clean up any resources being used.
/// </summary>
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
}
#region Windows Form Designer generated code
/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
private void InitializeComponent()
{
this.mainMenu1 = new System.Windows.Forms.MainMenu();
60
this.menuVoltar = new System.Windows.Forms.MenuItem();
this.menuConsultar = new System.Windows.Forms.MenuItem();
this.txtNumero = new System.Windows.Forms.TextBox();
this.label1 = new System.Windows.Forms.Label();
this.label2 = new System.Windows.Forms.Label();
this.txtSituacao = new System.Windows.Forms.TextBox();
this.label3 = new System.Windows.Forms.Label();
this.label4 = new System.Windows.Forms.Label();
this.txtNota = new System.Windows.Forms.TextBox();
this.txtClassificacao = new System.Windows.Forms.TextBox();
//
// mainMenu1
//
this.mainMenu1.MenuItems.Add(this.menuVoltar);
this.mainMenu1.MenuItems.Add(this.menuConsultar);
//
// menuVoltar
//
this.menuVoltar.Text = "Voltar";
this.menuVoltar.Click += new
System.EventHandler(this.menuVoltar_Click);
//
// menuConsultar
//
this.menuConsultar.Text = "Consultar";
this.menuConsultar.Click += new
System.EventHandler(this.menuConsultar_Click);
//
// txtNumero
//
this.txtNumero.Location = new System.Drawing.Point(3, 25);
this.txtNumero.Size = new System.Drawing.Size(170, 24);
//
// label1
//
this.label1.Font = new System.Drawing.Font("Nina", 10F,
System.Drawing.FontStyle.Bold);
this.label1.Location = new System.Drawing.Point(3, 0);
this.label1.Size = new System.Drawing.Size(73, 22);
this.label1.Text = "Número:";
//
// label2
//
this.label2.Font = new System.Drawing.Font("Nina", 10F,
System.Drawing.FontStyle.Bold);
this.label2.Location = new System.Drawing.Point(4, 56);
this.label2.Size = new System.Drawing.Size(62, 22);
this.label2.Text = "Situação:";
//
// txtSituacao
//
this.txtSituacao.Font = new System.Drawing.Font("Nina", 10F,
System.Drawing.FontStyle.Regular);
this.txtSituacao.Location = new System.Drawing.Point(107,
53);
this.txtSituacao.Size = new System.Drawing.Size(66, 23);
//
// label3
//
61
this.label3.Font = new System.Drawing.Font("Nina", 10F,
System.Drawing.FontStyle.Bold);
this.label3.Location = new System.Drawing.Point(3, 85);
this.label3.Size = new System.Drawing.Size(63, 17);
this.label3.Text = "Nota:";
//
// label4
//
this.label4.Font = new System.Drawing.Font("Nina", 10F,
System.Drawing.FontStyle.Bold);
this.label4.Location = new System.Drawing.Point(3, 115);
this.label4.Size = new System.Drawing.Size(87, 17);
this.label4.Text = "Classificação:";
//
// txtNota
//
this.txtNota.Font = new System.Drawing.Font("Nina", 10F,
System.Drawing.FontStyle.Regular);
this.txtNota.Location = new System.Drawing.Point(107, 85);
this.txtNota.Size = new System.Drawing.Size(66, 23);
//
// txtClassificacao
//
this.txtClassificacao.Font = new System.Drawing.Font("Nina",
10F, System.Drawing.FontStyle.Regular);
this.txtClassificacao.Location = new
System.Drawing.Point(107, 116);
this.txtClassificacao.Size = new System.Drawing.Size(66, 23);
//
// frmNumero
//
this.ClientSize = new System.Drawing.Size(176, 180);
this.Controls.Add(this.label1);
this.Controls.Add(this.txtNumero);
this.Controls.Add(this.label2);
this.Controls.Add(this.txtSituacao);
this.Controls.Add(this.label3);
this.Controls.Add(this.label4);
this.Controls.Add(this.txtNota);
this.Controls.Add(this.txtClassificacao);
this.Menu = this.mainMenu1;
this.Text = "Consulta Número";
}
#endregion
private void menuVoltar_Click(object sender, EventArgs e)
{
// Instancia um objeto do tipo frmInicial
frmInicial frmNovo = new frmInicial();
// Chama o formulário instanciado
frmNovo.ShowDialog();
}
private void menuConsultar_Click(object sender, EventArgs e)
{
DataSet ds =
objVestibular.consultarPorNumero(txtNumero.Text);
62
for (int i = 0; (i <= (ds.Tables[0].Rows.Count - 1)); i++)
{
txtNota.Text = ds.Tables[0].Rows[i].ItemArray[1];
txtSituacao.Text=ds.Tables[0].Rows[i].ItemArray[2];
txtClassificacao.Text =
ds.Tables[0].Rows[i].ItemArray[3];
}
}
}
}
63
ANEXO C
Classe gerada para referenciar o Web Service com a aplicação
Reference.cs
64
Reference.cs:
//----------------------------------------------------------------------------// <auto-generated>
//
This code was generated by a tool.
//
Runtime Version:2.0.50727.42
//
//
Changes to this file may cause incorrect behavior and will be lost
if
//
the code is regenerated.
// </auto-generated>
//----------------------------------------------------------------------------//
// This source code was auto-generated by
Microsoft.CompactFramework.Design.Data, Version 2.0.50727.42.
//
namespace sPhone.Vestibular {
using System.Diagnostics;
using System.Web.Services;
using System.ComponentModel;
using System.Web.Services.Protocols;
using System;
using System.Xml.Serialization;
using System.Data;
/// <remarks/>
[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.ComponentModel.DesignerCategoryAttribute("code")]
[System.Web.Services.WebServiceBindingAttribute(Name="ServiceSoap",
Namespace="http://tempuri.org/")]
public class Service :
System.Web.Services.Protocols.SoapHttpClientProtocol {
/// <remarks/>
public Service() {
this.Url = "http://localhost/WSSeguro/Service.asmx";
}
/// <remarks/>
[System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempur
i.org/consultarPorNome", RequestNamespace="http://tempuri.org/",
ResponseNamespace="http://tempuri.org/",
Use=System.Web.Services.Description.SoapBindingUse.Literal,
ParameterStyle=System.Web.Services.Protocols.SoapParameterStyle.Wrapped)]
public System.Data.DataSet consultarPorNome(string nomeCandidato,
int idCurso) {
object[] results = this.Invoke("consultarPorNome", new
object[] {
nomeCandidato,
idCurso});
return ((System.Data.DataSet)(results[0]));
}
65
/// <remarks/>
public System.IAsyncResult BeginconsultarPorNome(string
nomeCandidato, int idCurso, System.AsyncCallback callback, object
asyncState) {
return this.BeginInvoke("consultarPorNome", new object[] {
nomeCandidato,
idCurso}, callback, asyncState);
}
/// <remarks/>
public System.Data.DataSet
EndconsultarPorNome(System.IAsyncResult asyncResult) {
object[] results = this.EndInvoke(asyncResult);
return ((System.Data.DataSet)(results[0]));
}
/// <remarks/>
[System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempur
i.org/consultarPorNumero", RequestNamespace="http://tempuri.org/",
ResponseNamespace="http://tempuri.org/",
Use=System.Web.Services.Description.SoapBindingUse.Literal,
ParameterStyle=System.Web.Services.Protocols.SoapParameterStyle.Wrapped)]
public System.Data.DataSet consultarPorNumero(string idCandidato)
{
object[] results = this.Invoke("consultarPorNumero", new
object[] {
idCandidato});
return ((System.Data.DataSet)(results[0]));
}
/// <remarks/>
public System.IAsyncResult BeginconsultarPorNumero(string
idCandidato, System.AsyncCallback callback, object asyncState) {
return this.BeginInvoke("consultarPorNumero", new object[] {
idCandidato}, callback, asyncState);
}
/// <remarks/>
public System.Data.DataSet
EndconsultarPorNumero(System.IAsyncResult asyncResult) {
object[] results = this.EndInvoke(asyncResult);
return ((System.Data.DataSet)(results[0]));
}
/// <remarks/>
[System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempur
i.org/consultarCursos", RequestNamespace="http://tempuri.org/",
ResponseNamespace="http://tempuri.org/",
Use=System.Web.Services.Description.SoapBindingUse.Literal,
ParameterStyle=System.Web.Services.Protocols.SoapParameterStyle.Wrapped)]
public System.Data.DataSet consultarCursos() {
object[] results = this.Invoke("consultarCursos", new
object[0]);
return ((System.Data.DataSet)(results[0]));
}
/// <remarks/>
66
public System.IAsyncResult
BeginconsultarCursos(System.AsyncCallback callback, object asyncState) {
return this.BeginInvoke("consultarCursos", new object[0],
callback, asyncState);
}
/// <remarks/>
public System.Data.DataSet EndconsultarCursos(System.IAsyncResult
asyncResult) {
object[] results = this.EndInvoke(asyncResult);
return ((System.Data.DataSet)(results[0]));
}
}
}