Javafx
70
CENTRO UNIVERSITÁRIO DE MARINGÁ CURSO DE PÓS-GRADUAÇÃO EM DESENVOLVIMENTO ORIENTADO A OBJETOS - JAVA Márcio Mitsunori Noda JavaFX: Implementação na Prática MARINGÁ 2009
-
Upload
andreia-dias -
Category
Documents
-
view
335 -
download
0
description
javafx
Transcript of Javafx
CENTRO UNIVERSITÁRIO DE MARINGÁ
CURSO DE PÓS-GRADUAÇÃO EM DESENVOLVIMENTO ORIENTADO A
OBJETOS - JAVA
Márcio Mitsunori Noda
JavaFX: Implementação na Prática
MARINGÁ 2009
Márcio Mitsunori Noda
JavaFX
MARINGÁ 2009
Monografia apresentada ao Centro Universitário de Maringá como requisito para obtenção do título de especialista em Desenvolvimento Orientado a Objetos -JAVA, sob orientação do prof. Munif Gebara Junior.
AGRADECIMENTOS
Aos meus pais por todo incentivo, apoio e confiança.
Ao professor Munif Gebara Junior, meu orientador, obrigado por toda
sua atenção e dedicação, e principalmente pela motivação que se mostraram
indispensáveis a este trabalho.
Em especial, ao meu primo Fabrício que colaborou com o papel de
leiautista no desenvolvimento deste trabalho.
RESUMO
JavaFX sendo uma tecnologia recente, desenvolvida com a finalidade de
implementação de interfaces ricas (RIA – Rich Internet Application), ainda não
consolidada no mercado, no presente trabalho será avaliado os custos em tempo,
trabalho requerido, desempenho em produção e complexidade no desenvolvimento
de pequenos exemplos práticos sob a plataforma.
Por seguinte, submeter tais implementações em testes de execução sob as
plataformas, browser (navegador), desktop e em dispositivos móveis, tal como
divulgado pelo fornecedor.
Palavras-chave: JavaFX , RIA.
LISTA DE FIGURAS
Figura 1. Primeiro Projeto .................................................................................................... 34 Figura 2. Primeiro Projeto sob os dispositivos HTC ........................................................... 35 Figura 3. Projeto Calculadora nos dispositivos HTC ........................................................... 36 Figura 4. Calculadora ........................................................................................................... 39 Figura 5. Projeto Agenda sob os dispositivos HTC ............................................................. 40 Figura 6. Agenda .................................................................................................................. 41
LISTA DE TABELAS
Tabela 1. Temas RIA ............................................................................................................ 16 Tabela 2. Comparação dentre desktop, web e RIA .............................................................. 18 Tabela 3. Classificação dos tipos de RIA ............................................................................. 19 Tabela 4. Recursos de destaque do JavaFX ......................................................................... 26 Tabela 5. Formas de implantação ......................................................................................... 29
9
LISTA DE QUADROS
Quadro 1. Controle contra travamentos. ............................................................................ 32 Quadro 2. Código fonte do Primeiro Projeto ..................................................................... 34 Quadro 3. Classe Java Calculadora ................................................................................... 37 Quadro 4. Trecho de código da classe InterfacePadraoView ........................................... 37 Quadro 5. Trecho de código da classe Controller ............................................................. 38 Quadro 6. Conteúdo XML retornado pelo servidor .......................................................... 40 Quadro 7. Arquivo ManutencaoContatoView_en_US.fxproperties.................................. 42 Quadro 8. Trecho de código da classe ManutencaoContatoView ..................................... 43 Quadro 9. Trecho de código da classe BaseDeDados ...................................................... 43 Quadro 10. Trecho de código da classe RequisicaoServidor ............................................. 45
10
SUMÁRIO
AGRADECIMENTOS ............................................................................................................... 1 RESUMO ................................................................................................................................... 2 LISTA DE FIGURAS ................................................................................................................ 3 LISTA DE TABELAS ............................................................................................................... 4 LISTA DE QUADROS .............................................................................................................. 9 SUMÁRIO ................................................................................................................................ 10 1. INTRODUÇÃO ................................................................................................................ 11
1.1. Objetivos ................................................................................................................... 12 1.2. Metodologia .............................................................................................................. 13 1.3. Organização do Trabalho.......................................................................................... 13
2. Revisão Bibliográfica ....................................................................................................... 15 2.1. Rich Internet Application - RIA ............................................................................... 15 2.2. Tecnologias Similares .............................................................................................. 19 2.3. Breve Histórico da Evolução do JavaFX .................................................................. 20 2.4. JavaFX 1.0 ................................................................................................................ 21 2.5. JavaFX 1.1 ................................................................................................................ 22 2.6. JavaFX 1.2 ................................................................................................................ 22 2.7. JavaFX TV ................................................................................................................ 23 2.8. JavaFX Mobile ......................................................................................................... 23 2.9. JavaFX Script ........................................................................................................... 24 2.10. Divisão por Perfis ................................................................................................. 25 2.11. Colaboração entre Designers e Desenvolvedores ................................................. 27 2.12. Implantação .......................................................................................................... 28 2.13. Java Sandbox ........................................................................................................ 30
3. Desenvolvimento JavaFX ................................................................................................. 32 3.1. Primeiro Projeto ........................................................................................................ 33 3.2. Projeto Calculadora .................................................................................................. 35
3.2.1. Integração com Java ......................................................................................... 36 3.3. Projeto Agenda ......................................................................................................... 39
3.3.1. Lado servidor .................................................................................................... 40 3.3.2. Lado cliente ...................................................................................................... 41 3.3.3. Internacionalização ........................................................................................... 41 3.3.4. Persistência de dados ........................................................................................ 43 3.3.5. Integração ......................................................................................................... 44
4. CONCLUSÕES e TRABALHOS FUTUROS ................................................................. 47 5. REFERÊNCIAS ............................................................................................................... 50 6. BIBLIOGRAFIA CONSULTADA .................................................................................. 55 7. APÊNDICES .................................................................................................................... 56
7.1. APÊNDICE A - Código Fonte do primeiro exemplo ............................................... 57 7.2. APÊNDICE B – Código fonte da classe InterfacePadraoView ............................... 58 7.3. APÊNDICE C – Código fonte da classe Controller ................................................. 61 7.4. APÊNDICE D – Código fonte da classe ManutencaoContatoView ....................... 65 7.5. APÊNDICE E – Código fonte da classe BaseDeDados ........................................... 68 7.6. APÊNDICE F – Código fonte da classe RequisicaoServidor .................................. 70
8. ANEXOS .......................................................................................................................... 72
11
1. INTRODUÇÃO
A plataforma JavaFX, recente tecnologia lançada pela Sun Microsystems
para o desenvolvimento de interfaces ricas e interativas, oferece conteúdos
expressivos para browsers (navegadores), desktops, dispositivos móveis, televisores
e futuramente para outras plataformas, que poderá englobar desde aplicações
embarcadas em automóveis até em sistemas de jogos eletrônicos, unificando o
desenvolvimento e implantação de modelos de interfaces mais expressivos.
Seguindo o mesmo slogan criado pela Sun Microsystem, "write once, run anywhere"
(“escreva uma vez, execute em qualquer lugar”), promete a realização no futuro,
onde os consumidores poderão acessar o mesmo conteúdo em diversas plataformas
que suportem Java (SUN, 2007a, 2009a, 2009b).
Devido ao ambiente de execução bastante diversificado, mesmo que em
algumas plataformas liberado no momento apenas como early access, i.e., o acesso
antecipado ao produto antes da versão final ser efetivamente disponibilizada ao
público geral, pode ser considerada uma das plataformas RIA mais amplamente
disponível para implantação no mercado, abrangendo todos os grandes principais
consumidores e sistemas operacionais corporativos (SUN, 2009b, 2009g).
Como parte desta tecnologia, foi introduzido o JavaFX Script, uma nova
linguagem de programação simples e intuitiva, semelhante ao Java, que possui a
vantagem de execução sob a JRE (Java Runtime Environment), pelo o qual poderá
garantir a segurança e a onipresença da plataforma Java, apoiando todos os
conteúdos e aplicações atualmente disponíveis através dos bilhões de dispositivos
em uso hoje. O JavaFX Script é a única tecnologia que oferece uma estreita
integração com componentes Java que pode ser executado tanto em servidores
como em clientes, resultando em uma rica experiência end-to-end (fim a fim) (SUN,
2007a, 2007c).
Entre as muitas inovações do JavaFX é a característica denominada Drag-
to-Install (“soltar para instalar”), pelo o qual permite que usuários finais possam pela
primeira vez efetuar a operação de drag-and-drop (literalmente, arrastar e soltar)
para a instalação de aplicações JavaFX. Em outras palavras possibilita que
programas JavaFX que estejam em execução no navegador web como applets,
12
sejam movidos diretamente para a área de trabalho (desktop), proporcionado aos
usuários a mais simples experiência de instalação de softwares de Internet e
conteúdo (SUN, 2008a).
Atualmente o JavaFX ganhou um significante papel no mercado alcançando
a marca de mais de 250 milhões de instalações do JRE, e 400 mil downloads do
SDK (Software Development Kit) desde dezembro de 2008 (SUN, 2009b).
Outro ponto de destaque está no conteúdo criativo, desempenhado por
designers, responsáveis pela função artística, a possibilidade de se tornarem
também desenvolvedores Java, devido ao fácil e rápido processo de construção de
interfaces ricas, que requer menos codificação, e incluem componentes de
visualização de dados e aplicações de inteligência de negócios (MAREJKA, 2007;
SUN, 2009b, 2007a).
Atualmente pode ser considerado competitivo ou superior as soluções
similares presentes no mercado para o desenvolvimento de GUI (Graphic User
Interface) tais como o: Macromedia Flash/Flex/Open Laszlo, Adobe Apollo, Microsoft
WPF/XAML, Mozilla XUL, AJAX/DHMTL e entre outros (OLIVER, 2006).
No seu ambiente de desenvolvimento incluem o compilador, ferramentas de
runtime para várias arquiteturas de PC (Personal Computer) e outros dispositivos
como gráficos, mídia, Web Services e bibliotecas para construção de interfaces
ricas, dentre outras ferramentas necessárias para a implementação da tecnologia.
Possui plugins para ambos os IDEs (Integrated Development Environment) mais
conhecidos, NetBeans e Eclipse (SUN, 2008a).
1.1. Objetivos
O foco deste trabalho será centrado na tecnologia JavaFX, tendo como
objetivo apresentar uma visão geral, e demonstrar parte de suas funcionalidades
através de exemplos práticos, abordando seus principais aspectos positivos e
negativos, bem como os conceitos envolvidos. Os detalhamentos da linguagem
JavaFX Script tais como sintaxes, semântica, e nuances da API, serão
demonstrados de maneira superficial.
13
Embora o nome completo da plataforma JavaFX é JavaFX Rich Client,
sendo composto ainda por vários outros componentes, no contexto do trabalho o
termo será simplificado, sendo referenciado apenas como JavaFX. (WEAVER,
2009).
1.2. Metodologia
Como critério de desenvolvimento foi adotado a utilização do IDE Netbeans,
em função do plugin disponível para o IDE Eclipse ainda não apresentar-se com
nível de maturidade adequado, estando na versão beta no decorrer da
implementação dos exemplos. Outro ponto considerado, é o fato do Netbeans ser o
IDE oficial para o desenvolvimento na plataforma JavaFX, e possuir atualizações
com maior frequência.
Como restrição de plataforma, o ambiente de execução desktop e web foram
delimitados somente ao sistema operacional Windows, em virtude dos demais
sistemas operacionais, o ambiente JavaFX ainda não atingiu o estágio adequado de
maturidade (SUN, 2009a).
Com relação ao conteúdo exposto, serão abordados as revisões
bibliográficas baseados somente até o release JavaFX 1.2, visto que novas versões
ou revisões poderão ser disponibilizadas no decorrer do trabalho, podendo impactar
diretamente no desenvolvimento deste, e possivelmente, inviabilizando o
acompanhamento desta evolução.
1.3. Organização do Trabalho
O texto da monografia foi organizado em 4 capítulos: introdução, revisão
bibliográfica, implementação e conclusões.
No segundo capítulo são abordados a revisão bibliográfica, onde serão
apresentados o introdução sobre RIA, por seguinte, o histórico de evolução da
tecnologia, os principais fundamentos da linguagem JavaFX Script e grande parte de
sua estrutura, bem como, os principais conceitos envolvidos.
14
O terceiro capítulo trata-se da implementação de exemplos, formalizando o
conteúdo desenvolvido neste trabalho, que serviram de base para a demonstração,
o acompanhamento e o funcionamento, na prática, do desenvolvimento de
pequenos aplicativos utilizando a tecnologia JavaFX.
No último capítulo expõe as conclusões obtidas e as propostas para
trabalhos futuros.
15
2. Revisão Bibliográfica
As aplicações baseadas no HTML (Hyper Text Markup Language) tornaram-
se populares devido ao baixo custo de desenvolvimento, de arquitetura simples, fácil
manuseio e aprendizado. Entretanto os benefícios foram compensados com uma
perca significativa de algumas funcionalidades de UI (User Interface), devido a
simplicidade na paleta limitada de componentes e em seu modelo de interação
restrita. Tais recursos de interfaces podem ser exigidos por softwares mais
complexos que requerem alta interatividade, não se limitando a atualização de várias
páginas HTML para completar uma transação (O'ROURKE, 2004; SUN, 2007a;
WEAVER, 2009).
Outro ponto negativo do HTML é com relação a codificação, que apesar de
iniciar-se de maneira simples, pode requerer uma grande quantidade de esforço
para efetuar tarefas sem maiores complicações de interface (O'ROURKE, 2004).
2.1. Rich Internet Application - RIA
O termo ”Rich Internet Application” - RIA, foi introduzido pela Macromedia
por Jeremy Allaire em março de 2002, para iniciar a unificação das aplicações do
tradicional desktop e web, no sentido de utilizar as vantagens e superar as
desvantagens de ambas as arquiteturas. As primeiras aplicações RIA originaram-se
em 1995, através dos pequenos programas chamados de Java applets, que podem
ser executados via browser sob a máquina virtual Java (JVM - Java Virtual Machine),
com algumas restrições de segurança (BOZZON, 2006).
O princípio básico é proporcionar um tempo de execução eficiente e de alta
performance para a execução do código, tanto no conteúdo quanto na comunicação.
Inclui a requisição/resposta para a página de renderização do modelo, a
necessidade de gerar dinamicamente um grande conteúdo de texto para a simples
transmissão de dados, o armazenamento de dados no lado do cliente, e a
possibilidade de se invocar a lógica de negócios remotamente (lado do servidor) e a
facilidade de se manipular-los. O RIA fornece poderosos e extensivos modelos de
16
objetos para interatividade em termos de aplicações e eventos. Esses modelos
baseados em objetos, devem se integrar com a interface do usuário, e a
comunicações e serviços a nível de sistema (ALLAIRE, 2002).
A construção de RIAs com metodologias de engenharia da Web requer
adaptação do fluxo de desenvolvimento de aplicações Web tradicionais, para
considerar a capacidade do novo lado do cliente, a nova característica de
apresentação, bem como os diferentes mecanismos de comunicação entre o
servidor e o cliente. As principais questões correlacionadas com a concepção do RIA
podem ser agrupados em quatro temas conforme a Tabela 1 (LINAJE, 2008):
Tema Descrição
Dados O conteúdo volátil e persistente são armazenados e manipulados
no lado do cliente e do servidor (LINAJE, 2008);
Lógica de
negócio
Em ambos os lados, tanto o cliente quanto o servidor podem
realizar operações complexas (LINAJE, 2008);
Comunicação Permite a comunicação assíncrona, bem como a distribuição de
dados e de funcionalidades entre o cliente e o servidor; ampliam as
características dos eventos produzidos tais como podem se
originar, detectar, notificar, ou ser processado em uma variedade
de maneiras (LINAJE, 2008);
Apresentação Oferece apresentações aprimoradas de interações com o usuário,
permitindo-o operar como aplicações em uma única página
(LINAJE, 2008).
Tabela 1. Temas RIA
O RIA utiliza-se de um motor de renderização relativamente robusto no
modelo client-side, que podem apresentar-se muito densas, responsiva e
graficamente rica em interface ao usuário. Podem ainda oferecer uma ampla
variedade de controles, e geralmente podem permitir a construção de gráficos em
tempo real através de qualquer SVG (Scalable Vector Graphics) ou algum outro tipo
de mecanismo (O'ROURKE, 2004).
17
Outro benefício do RIA em comparação com o HTML é que os dados podem
ser armazenados em cache no cliente, permitindo uma interface mais ágil com
menos trafego de informações com o servidor. Em muitos casos, o cliente pode
permanecer conectado à fonte de dados, possibilitando que servidor possa atualizar
o cliente em tempo real. Alem disso, tal recurso possibilita o desenvolvimento de
aplicações que podem ser projetadas para trabalhar no modo offline, recurso
necessário para seu funcionamento em dispositivos tais como o PDA (Personal
Digital Assistant), ou pelo menos degradar-se normalmente, mesmo quando a
conexão é perdida. Muitos aplicativos requerem o suporte para conexões
persistentes em dois sentidos, a notificação baseada em comunicações
(O'ROURKE, 2004; ALLAIRE, 2002).
A promessa de clientes ricos inclui a capacidade de separar a lógica de
apresentação limpa e interfaces de usuário a partir da lógica do aplicativo
hospedado na rede, permitindo o uso da Internet e serviços de dados fornecidos
pelos servidores de aplicação. O XML (Extensible Markup Language) é geralmente
utilizado como o formato de transferência de dados e, às vezes, também como
descritor de leiaute de formulário. Clientes ricos devem fornecer um modelo para
facilitar o uso de serviços remotos fornecidos por componentes de back-end, seja
hospedado em um servidor de aplicativos ou acessados como XML Web Service (
ALLAIRE, 2002; O'ROURKE, 2004)
A seguir é apresentada na Tabela 2 que faz uma comparação dentre as
características das plataformas desktop, web e RIA.
18
Característica Desktop Web RIA
Cliente universal (Navegador)
Não Sim Sim
Instalação no Cliente Complexo Simples Simples
Capacidade de interação
Rico Limitado Rico
Lógica de negócio no lado do Servidor
Sim Sim Sim
Lógica de negócio no lado do Cliente
Sim Limitado Sim
Total atualização de página requerida
Não Sim Não
Comunicação Servidor-Cliente
Sim Não Sim
Funcionamento Offline
Sim Não Sim
Tabela 2. Comparação dentre desktop, web e RIA
Dentre as mais conhecidas tecnologias para o desenvolvimento de
aplicações ricas para Internet se destacam: AJAX, Flash, FLEX, OpenLaszlo,
Silverlight, entre outras novas, como o próprio JavaFX que ainda estão emergindo
no mercado (LINAJE, 2008).
As aplicações ricas, no contexto geral, podem ser classificadas da conforme
a Tabela 3 :
19
Classificação Definição
Baseado em script A lógica no lado do cliente é implementada via
linguagem de scripts, tal como o JavaScript, cujo as
interfaces são baseadas na combinação dentre HTML e
CSS (Cascading Style Sheets) (BOZZON, 2006);
Baseado em plugin A renderização avançada e o processamento de eventos
são concedidos através de plugins do navegador, por
meio de interpretação de dados no formato XML.
Também podem ser disponibilizados via programas de
uso geral ou arquivos de multimídia, como o Flash, Flex,
Laszlo, entre outros (BOZZON, 2006);
Baseado no navegador
(browser)
A rica interação é nativamente suportado por alguns
navegadores que podem interpretar linguagens de
definição de interface declarativa, tais como o XUL - XML
User Interface Language (BOZZON, 2006);
Tecnologias desktop
baseado em web
Pode ser definido como as aplicações que podem ser
baixadas e executadas diretamente pela web, isto é, a
execução de programas de Internet no qual são
transferidos para área de trabalho (local), porém é
executado fora do browser, como por exemplo o Java
Web Start e o Window Smart Client (BOZZON, 2006).
Tabela 3. Classificação dos tipos de RIA
2.2. Tecnologias Similares
Como principais concorrentes diretos do JavaFX foram selecionados as
seguintes tecnologias já consolidadas no mercado: AJAX (Asynchronous Javascript
and XML), FLEX e o Silverlight.
Baseado na linguagem Javascript, o AJAX, atua no lado cliente, sendo
desenvolvido para a criação de aplicações Web com maior interatividade, com o
20
propósito de se evitar a atualização de páginas HTML. Os dados podem ser
recuperados de forma assíncrona utilizando-se do objeto XMLHttpRequest sem a
necessidade de se recarregar a interface inteira. Muitos frameworks estão
disponíveis para o desenvolvimento com o AJAX, pelo o qual tentam contornar o
problema das diferenças dentre os navegadores (LINAJE, 2008);
O FLEX, é um produto open source com maturidade comercial para o
desenvolvimento de interfaces ricas, fornecido pelo Adobe System, pelo qual se
utiliza de duas linguagens: o MXML, com sintaxe declarativa baseado em XML; e o
ActionScript, definida como uma linguagem de programação avançada. Com o
MXML é possível descrever os comportamentos e leiaute de interface de usuário, e
o ActionScript para implementação da lógica no lado do cliente. As principais
desvantagens de ambos em Flash e Flex é o suporte limitado para XML e padrões
de Web Services e a relativa imaturidade do ambiente como uma ferramenta de
desenvolvimento de aplicações. Por outro lado, as principais vantagens é a
facilidade com a qual é possível criar-se animações complexas e a disponibilidade
de complementos de terceiros. O Flex inclui uma biblioteca de componentes
compostos por 100 itens para a construção de interfaces, além de um depurador
interativo de aplicativos Flex (ADOBE, 2009; LINAJE, 2008; O'ROURKE, 2004);
Por fim, o SilverLight trata-se de uma tecnologia baseado no WPF (Windows
Presentation Foundation), sendo uma plataforma da Microsoft para o
desenvolvimento RIA. Seguindo o mesmo caminho dos demais concorrentes, o
Silverlight possui também uma linguagem declarativa baseada em XML, o XAML
(Extensible Application Markup Language), tendo como base do recurso de
apresentação do Microsoft .NET Framework 3.0 (infra-estrutura de programação
Windows) (LINAJE, 2008; MORONEY, 2007).
2.3. Breve Histórico da Evolução do JavaFX
O projeto iniciou-se em setembro de 2005 com a aquisição da empresa
SeeBeyond Technology Corporation. A obtenção trouxe para a Sun Microsystems o
engenheiro sênior, Christopher Oliver, desenvolvedor do projeto chamado F3 (forms
21
folows function), também conhecido como JFX, no qual mais tarde foi rebatizado
como JavaFX Script (OLIVER, 2006, 2007).
O JavaFX foi anunciado pela primeira vez em maio de 2007 na conferência
JavaOne WorldWide Java Developer. No mesmo período, também foi divulgado a
aquisição completa das propriedades intelectuais da empresa Savaje Technologies,
que teve como um de seus objetivos, expandirem o mercado de dispositivos móveis
integrados com a tecnologia Java como client-side. (SUN, 2007b)
A primeira versão do JavaFX, considerada um protótipo, foi disponibilizada
ao público como uma linguagem interpretada, permitindo que desenvolvedores, após
sua “degustação”, contribuir com feedbacks para a evolução do produto. Dois livros
foram publicados no período de 2007, baseados nesta versão (WEAVER, 2009).
Em abril de 2008 com o lançamento do JRE 6 Update 10 (6u10), também
publicado no artigo por Ethan Nicholas, incluiu componentes e recursos adicionais
para o suporte ao runtime do JavaFX, desenvolvido inicialmente voltado para a
plataforma Windows 32-bit, sendo considerado um marco para a nova tecnologia,
dentre outras inovações. O release trouxe soluções para o JRE no problema de
implantação de aplicações desenvolvidas sob o JavaFX, que exigia o runtime
específico para sua execução (KRILL, 2008; NICHOLAS, 2008; SUN, 2008b).
Por seguinte, em maio de 2008 a Sun Microsystems anunciou o plano de
entrega do JavaFX para as plataformas browser e desktop para o terceiro trimestre
do mesmo ano, e em sequência para dispositivos móveis no segundo trimestre de
2009. Uma prévia do JavaFX foi liberado em julho de 2008 (SUN, 2009a).
2.4. JavaFX 1.0
Oficialmente o JavaFX foi lançado em 4 de dezembro de 2008, com a
liberação da primeira versão, o release 1.0, composto por três componentes chaves:
o SDK, a ferramenta JavaFX Production Suite, e o JavaFX Desktop. Inicialmente foi
disponibilizado para os sistemas operacionais Windows e MacOSX, compondo uma
nova família de produtos baseados na tecnologia Java. (SUN, 2008a, 2009a)
O JavaFX 1.0 incluiu no pacote um completo conjunto de efeitos gráficos,
aliado ao sofisticado framework de aceleração gráfica via hardware (GPU – Graphic
22
Processor Unit), quando disponível no dispositivo ou na plataforma. Também foi
adicionado o suporte para exibição de vídeos através do uso de decodificadores
nativos para cada plataforma, o VP6, fornecido pela empresa On2 Technologies,
Inc., parceiro da Sun, líder em soluções de compreensão de vídeos (OLIVER, 2009;
SUN, 2008a, 2008j).
2.5. JavaFX 1.1
Na sequência, em 12 de fevereiro de 2009, foi oficializado o release do
JavaFX 1.1 que anunciou o esperado JavaFX Mobile, pelo o qual forneceu um
completo sistema de software para dispositivos móveis via licença OEM (Original
Equipment Manufacturer) para fabricantes e outras companhias que desejem aderir
a nova plataforma. Incluiu no pacote algumas vantagens, dentre que se destacam, o
aumento de performance, a implementação dos tipos numéricos da linguagem Java
(float, double, long, int, short, e byte) no JavaFX Script e a compatibilidade binária
com o release anterior, o JavaFX 1.0 (O'NEILL, 2007; SUN, 2009a, 2009f).
O lançamento contou ainda com adesão de novos parceiros para a nova
tecnologia JavaFX, composto por conhecidos fabricantes e prestadores de serviços,
como: Sony Ericsson, LG Electronics, Orange, Sprint, Cynergy e MobiTV (SUN,
2009f).
2.6. JavaFX 1.2
No último update, o JavaFX 1.2, lançado em 2 de junho de 2009, entregou
significantes atualizações, tais como o suporte como early acess aos sistemas
operacionais Linux e OpenSolaris, a adição de novas bibliotecas de interfaces (GUI),
o aprimoramento considerável de performance através do runtime Java SE 6 Update
14, dentre outras mudanças que visando maiores melhorias, ocasionaram
incompatibilidades de API (Application Programming Interface) com as versões
anteriores. Tais alterações de maiores impactos incluíram a remoção/ renomeação
de classes e variáveis, antes presentes no SDK 1.1, e a introdução de outras novas
na versão corrente, que resultou em binários inconciliáveis dentre o JavaFX 1.1 e
23
1.2. Sendo assim, todas as bibliotecas codificadas nos releases anteriores, bem
como suas dependências, precisam ser recompiladas para migrarem para a versão
mais atual (CHO, 2009; SUN, 2009a, 2009b, 2009e)
O SDK 1.2 ainda foi complementado com o preview do JavaFX TV, exposto
pela primeira vez ao público no evento Java One Conference de 2009, completando
a visão de aplicações JavaFX funcionando em navegadores, desktops, dispositivos
móveis e televisores. Também anunciado na conferência, destacou-se a
demonstração prévia da ferramenta JavaFX Authoring Tool, pelo o qual permite que
designers e desenvolvedores construam suas aplicações de forma visual (SUN,
2009b).
A Sun Microsystems demonstrando seu com o comprometimento para o
código livre, como parte do modelo de negócio, forneceu o compilador do JavaFX,
incluindo parte das bibliotecas de gráficos e ferramentas para o projeto OpenJFX,
sob a licença GPL (General Public License) 2.0. O projeto do compilador OpenJFX
possui como foco a tradução de scripts JavaFX em arquivos de classes JVM,
compilados como bytecodes (OpenFX, 2009a; SUN, 2009j).
2.7. JavaFX TV
Com relação ao runtime do JavaFX TV, a Sun Microsystems alega estar
trabalhando com fabricantes de dispositivos, tendo a previsão inicial de disponibilizar
o JavaFX SDK aos desenvolvedores ao final de 2009. Na conferência JavaOne, em
junho de 2009, a Sun demonstrou uma prova de conceito do JavaFX rodando em
uma TV de próxima geração da LG Electronics TV. (SUN, 2009b, 2009j).
2.8. JavaFX Mobile
Atualmente foi disponibilizado um runtime para o sistema operacional
Windows Mobile, fornecido somente para fins de desenvolvimento. Os testes de
ambiente realizados pela Sun, utilizaram o JavaFX SDK 1.2 nos dispositivos HTC
Diamond e LG Incite touch (SUN, 2009l).
24
Na versão corrente ainda possui vários limitadores, tais como a execução de
somente uma aplicação JavaFX por vez, comportamentos dos controles de UI e
gráficos não confiáveis, dentre outros.
2.9. JavaFX Script
O JavaFX Script é uma linguagem de script baseado nas linguagens
Javascript, Miranda, SQL e Lisp. Derivou-se do projeto F3, que inicialmente não era
uma linguagem de programação, conceitualmente apresentava-se como um tipo de
linguagem de modelagem com notações de objetos UML (Unified Modeling
Language), consistindo apenas em declarações de classes e valores de constantes.
A plataforma JavaFX foi arquitetada para suportar múltiplas linguagens de script, tal
como as linguagens baseadas de marcação visual, como o XML. (OLIVER, 2006,
2007, 2009; O'NEILL, 2007; SUN, 2009j).
Nos conceitos técnicos, o JavaFX Script é uma linguagem procedural,
orientado a objetos, desenvolvida para a especificação de componentes de GUI,
composto por sintaxes e expressões declarativas (relações entre os componentes
gráficos interativos), inferência de tipos (baseado no contexto da variável o tipo de
dado é auto-interpretado pelo compilador), data-binding (sincronização automática
entre os dados da aplicação e os componentes de interfaces exibidos ao usuário)
com suporte a gráficos em duas dimensões e a padrões da API de componentes do
Swing. Diferentemente dos seus concorrentes do mercado, a linguagem JavaFX
Script é statically typed (estaticamente “tipado”), ou seja, o tipo do objeto é
conhecido pelo compilador baseado em sua declaração em tempo de compilação
(OLIVER, 2006, 2009; O'NEILL, 2007; SUN, 2009d).
Obtém as vantagens do modelo de programação Java, sendo inclusive
dependente de compilação, no qual seu código fonte necessita ser previamente
convertido para Java bytecode antes de estar disponível para a execução no
sistema. Alem disso, proporciona uma série de recursos derivados do Java tais
como a estruturação do código, encapsulamento, integração direta com o mesmo
(importação de classes, criação de objetos, chamada de métodos, implementação
de interfaces, entre outros), o reuso, o suporte nativo ao padrão de projeto com o
25
modelo MVC (Model View Control), dentre outras características que provêm a
possibilidade de fácil entendimento e manutenibilidade em grandes programas,
sendo capaz de suportar interfaces de qualquer tamanho de complexidade
(HOMMEL, 2009; OLIVER, 2006, 2009; O'NEILL, 2007; SUN, 2009a, 2009c, 2009d).
O conceito central da linguagem JavaFX, relacionado a UI, é baseado no
scene graph (grafo de cena). O scene graph trata-se de uma estrutura de dados,
semelhante a uma arvore, que define a hierarquia de gráficos em uma cena, onde
um único elemento é denominado como nó. Cada nó pode manipular diferentes tipos
de objetos (conteúdos), tais como componentes UI, textos, imagens e mídias.
Expressa um modelo de interface de fácil manipulação para anexar
comportamentos, tais como a animação e efeitos de transição, ou para vincular a
modelos de dados subjacente (SUN, 2009a; WEAVER, 2009).
2.10. Divisão por Perfis
No contexto geral, a plataforma pode ser dividida em três perfis, o comum
(common profile), desktop (desktop profile) e dispositivo móvel (mobile profile). No
entanto na atual versão, o JavaFX 1.2, estão disponíveis apenas o perfil comum e
desktop (SUN, 2009a; WEAVER, 2009).
O common profile, é o perfil comum da API no qual incluem classes
compartilhadas em ambas as plataformas, PC (incluindo o ambiente web) e
dispositivos móveis. Contém o núcleo de funcionalidades necessários para os
recursos de imagens, vídeos, textos, animações e chamada de serviços. É
suportado por todos os dispositivos que executam o JavaFX, tais como, PC,
telefones celulares e dentre outros (MALENKOV, 2009; SUN, 2009a; WEAVER,
2009).
No perfil desktop, baseado no Java SE (Java 2 Standard Edition), foram
adicionados funcionalidades e vantagens exclusivas da plataforma desktop, que
incluem componentes baseados no Swing, efeitos gráficos, dentre muitas outras
características não suportadas em dispositivos embarcados, tais como efeitos
visuais presentes no pacote javafx.scene.effect. O modelo é também suportado na
execução no browser (MALENKOV, 2009; SUN, 2009a; WEAVER, 2009).
26
No futuro será criado o mobile profile que poderá ser designado
especificamente para dispositivos móveis, baseado na implementação estendida do
JavaME (Java Micro Edition), que incluem recursos tais como o bluetooth, GPS
(Global Positioning System), detectores de movimento, e entre outros itens
relacionados aos aparelhos portáveis. Contudo, até essas características serem
efetivamente disponibilizadas, no momento, as referências ao perfil mobile é
equivalente ao common profile (SUN, 2009a; WEAVER, 2009).
Dentre outras características técnicas de destaque presentes na versão
atual (SDK 1.2), é exposto na Tabela 4 :
Recurso Descrição
Gerenciamento do
JavaFX I/O (In/Out)
Mascaram as diferenças entre o desktop e dispositivos móveis
(SUN, 2009a, 2009c);
Skinnable CSS
(Cascading Style
Sheets)
O Skin recurso responsável por toda aparência visual e,
ultimamente também pela interação visual com o controle, no
ambiente JavaFX, os atributos CSS podem ser especificados,
ou diretamente aplicados nos nós da cena do grafo, tal como
no HTML (BAIR, 2009);
Triggers (gatilhos) Conceitualmente pode ser definido como uma funcionalidade,
ou um trecho de código, que é invocado e executado
automaticamente em determinadas condições, tal como o
valor de um atributo é alterado. Métodos assessores (getters
e setters) podem ser substituídos através deste recurso,
simplificando a tarefa de desenvolvimento, bem como
evidenciando as vantagens da sintaxe declarativa e o uso do
encapsulamento (SUN, 2009a; WEAVER, 2009);
Gráficos Disponível no pacote javafx.scene.chart no perfil comum a
todas as plataformas, que contém os seguintes tipos de
gráficos: barras, área, bolha, linha e dispersão (SUN, 2009a;
WEAVER, 2009).
Tabela 4. Recursos de destaque do JavaFX
27
2.11. Colaboração entre Designers e Desenvolvedores
A interação entre os designers, responsáveis pela beleza da interface e a
efetividade da experiência do usuário, e os desenvolvedores que são focados pela
funcionalidade da aplicação, foi considerado um ponto fundamental. A articulação de
uma aplicação RIA de sucesso, alem de suas habilidades funcionais, é o seu apelo
estético, que evidencia a necessidade de uma intensa colaboração entre ambas as
partes (SUN, 2009h).
O JavaFX Production Suite é um produto separado, disponível para
download, como parte da plataforma JavaFX, pelo o qual foi designado e projetado
desde o início para suportar o fluxo de trabalho interativo, dentre desenvolvedores e
artistas, permitindo a substituição de novas versões dos elementos visuais sem
nenhuma alteração do código, simplificando o processo de importação de objetos
gráficos (SUN, 2009h).
O ambiente JavaFX cria uma separação entre recursos gráficos e de lógica
de negócios. Deste modo permite os designers modificarem seus projetos
frequentemente, enquanto manterem os nomes dos objetos gráficos intactos
(identificadores), os elementos de interface podem ser modificados sem qualquer
alteração na lógica de negócio. Devido a esta característica, possibilita que os
objetos gráficos possam ser transferidos para uma nova posição em tela sem causar
impactos ao modelo de negócio (SUN, 2009h).
Os gráficos exportados a partir da ferramenta JavaFX Production Suite
podem ser manipulados como objetos individuais (grupos, camadas, e alguns
efeitos) dentro do ambiente de desenvolvimento das aplicações JavaFX (SUN,
2009h).
Provê a facilidade aos desenvolvedores/designers para manipular objetos
gráficos individuais dentro de um recurso visual, bem como a opção de escolha das
ferramentas gráficas de sua preferência. Possui plugins para conversão de gráficos
originados do Adobe Illustrator ou Photoshop, para os formatos próprios do JavaFX,
cuja as extensões: FXZ e FXD (JavaFX Data Files) (SUN, 2009h).
Após realizar o processo de conversão a partir das ferramentas gráficas
gerando para o formato reconhecido pelo JavaFX, um novo arquivo é criado com a
28
extensão FXZ. O recipiente FXZ é um arquivo compactado utilizando-se da
compressão do tipo ZIP, logo seu conteúdo pode ser visualizado por qualquer
utilitário ZIP, ou por um editor de texto, caso descompactado manualmente; também
pode ser aberto pelo IDE Netbeans. Em seu conteúdo existe pelo menos um arquivo
FXD, pelo o qual é a descrição textual do gráfico, e em adição, pode incorporar
outros recursos gráficos, tais como arquivos de imagens ou fontes TrueType (SUN,
2009i).
A criação do novo formato FXD, que constitui de um mapeamento descritivo,
um-para-um, para os grafos de cena do JavaFX API, foi motivado devido as
dificuldades de representação dos elementos e das características presentes em
nos formatos, JavaFX Script e SVG, que deveriam ser compatíveis. Os objetos
gráficos podem preservar seus itens originais como camadas e atributos após serem
convertidos pelas ferramentas recomendadas (SUN, 2009h, 2009i).
2.12. Implantação
No ambiente de desenvolvimento estão disponíveis quatro formas distintas
para a implantação do software, conforme é exibido na Tabela 5 :
Plataforma Descrição
Execução Padrão (Standard)
Consiste em uma aplicação stand-alone destinado ao perfil
desktop, que pode ser inicializado por uma linha de comando,
por exemplo: javafx -jar <nome-do-aplicativo.jar> (CASTILLO,
2009);
Execução Web Start
Também como stand-alone, porém sua execução é feita através
da tecnologia Java Web Start, pelo o qual possibilita que
programas Java possam iniciar diretamente pelo browser,
executando fora do escopo do navegador (CASTILLO, 2009);
Execução no Browser
Baseado na execução em applet onde o software é embutido
dentro de uma página HTML para ser visualizado pelo browser
(CASTILLO, 2009; CHOUDHARY, 2009);
29
Execução no Mobile Emulator
(emulador da plataforma
mobile)
Executa o aplicativo como MIDlet, sob o JavaFX Mobile
Emulator, ferramenta que simula dispositivo no ambiente móvel.
A opção do simulador, no momento, está disponível apenas o
sistema operacional Windows (CASTILLO, 2009).
Tabela 5. Formas de implantação
A partir da plataforma Java 2 (desde da versão 1.4) com o surgimento do
Java Web Start – e da subjacente JNLP (Java Network Launch Protocol), tornaram-
se uma parte padrão que vieram para solucionar os problemas da arquitetura de
segurança, e as diferenças dentre os navegadores no contexto de client-side,
(ZUKOWSKI, 2002). O Acesso às extensões JNLP em applets, tem sido escrito para
aplicações Java Web Start, como a ligação para o Java 3D API OpenGL, e em
especial, para o grafo de cena para o runtime do JavaFX (SUN, 2007d).
Como ênfase no modo de instalação pela Internet, foi destacada as formas
de implantação por meio de applet e Java Web Start, ambos que se utilizam do
protocolo JNLP (SUN, 2009a; WEAVER, 2009).
A implantação via “drag and drog” foi disponibilizado após o release Java 6
Update 10, possibilitando a instalação de programas applet JavaFX através do
recurso de se arrastar a aplicação, com o mouse, para fora da janela do navegador,
mantendo a tecla ALT pressionada. O funcionamento do aplicativo, após sua
instalação, ocorre mesmo quando o browser estiver fechado (KOSTOVAROV, 2009;
WEAVER, 2009).
Uma aplicação Java Web Start pode ser implantada através de um
navegador apenas em sua primeira execução. Após a aplicação Java Web Start ser
baixada e depois do usuário aceitar o certificado de segurança, ele funciona quase
como um programa stand-alone. Tais aplicações também podem ser lançadas
através do menu Iniciar do SO Windows ou por meio de atalhos criados durante o
processo de instalação (KOSTOVAROV, 2009).
30
2.13. Java Sandbox
No contexto geral, a implantação via Internet, utilizando-se dos mecanismos
de applet ou Java Web Start, em termos de segurança, possuem diferenças
mínimas entre ambos, principalmente na forma como podem ser instalados no lado
cliente (KOSTOVAROV, 2009).
Um dos conceitos fundamentais de segurança no Java é a Sandbox Java,
no qual o JavaFX se beneficia, sendo esta uma das vantagens de segurança
oriundos do Java. O modelo de segurança sandbox é uma parte intrínseca da
arquitetura Java, fazendo parte como um elemento do Java Runtime Environment e
da API (KOSTOVAROV, 2009).
O modelo de segurança Java é focado em proteger os usuários de
programas hostis que podem ser baixados a partir de fontes não confiáveis na rede.
Para atingir esta meta, o runtime fornece uma proteção como uma “caixa de areia",
tal como sua tradução literal, sob os programas Java de procedências duvidosas
que são executados no ambiente (KOSTOVAROV, 2009).
Para os aplicativos implantados pela web, no caso via applets ou Java Web
Start, a JVM proíbe muitas atividades consideradas de risco a segurança do
sistema. Outros novos limites foram incluídos a partir do release Java 6 Update 10
(KOSTOVAROV, 2009).
A estrutura de segurança do sandbox tem como objetivo simplificar o
acesso a programas não assinados. Assim, o sistema de segurança não restringe
completamente os aplicativos não confiáveis, que podem partir de quaisquer fontes.
O sandbox apenas bloqueia a execução dos códigos considerados maliciosos,
oriundos de software não assinado, evitando possíveis danos que poderiam ser
causados. Por outro lado, caso o programa que tenta efetuar atividades
consideradas nocivas seja devidamente certificado, ou seja, assinado, o usuário
pode explicitamente permitir o acesso deste, através dos avisos de segurança
emitidos pelo runtime (KOSTOVAROV, 2009).
A assinatura é o meio legal para assegurar a execução do aplicativo no caso
do mesmo possuir rotinas não permitidas, assim, assinando-o digitalmente, são
concedidos os privilégios de segurança para exercer funcionalidades antes
31
indisponíveis. O processo, resumidamente, necessita do uso chaves públicas e
privadas para verificação da autenticidade do certificado de validade (SUN, 2009o).
Um arquivo de política pode ser definido para exigir uma assinatura em todos os
applets ou aplicações que tentam executar o arquivo de política. A assinatura é uma
maneira de verificar se o programa possui origens de uma fonte reconhecida, e pode
ser confiável para execução com as permissões concedidas no arquivo de diretiva
(AUSTIN, 1999).
Para a plataforma móvel, uma versão futura do JavaFX Mobile deverá apoiar
a política de segurança em camadas, em cima do Java ME (MSA - Mobile Service
Architecture) no modelo de segurança (KOSTOVAROV, 2009).
32
3. DESENVOLVIMENTO JAVAFX
Com o intuito de explorar o desenvolvimento de aplicativos sob a plataforma
JavaFX, no presente trabalho, são apresentados análises no desenvolvimento na
prática, através da implementação de simples exemplos.
Os tópicos abordados limitam-se aos controles comuns destinados a
construção de interfaces comerciais, tais como rótulos, campos de textos, botões e
dentre outros componentes atualmente disponíveis. Embora a parte estética da GUI,
recursos como efeitos, animações, transformações de objetos, dentre outros - sejam
importantes características do RIA, tais propriedades foram omitidas para garantir a
execução dos exemplos nos ambientes propostos.
Buscando o teste de execução nas plataformas propostas, desktop, móvel e
web, não foram utilizadas nenhuma das bibliotecas de terceiros atualmente
disponíveis nas implementações. Tal fato é justificado devido a possibilidade de tais
frameworks possuírem como dependência, recursos não suportados no JavaFX
Mobile.
Os programas foram implantados e testados nos ambientes: desktop, web,
mobile (simulador). Na prática foram submetidos aos dispositivos HTC modelos
P4351 e Diamond, portando o sistema operacional Windows Mobile, ambos com
poder de hardware acima dos requisitos mínimos necessários (SUN, 2009l).
Em virtude de erros ocorridos nos testes feitos nos aparelhos HTC, tal como
travamento do runtime do JavaFX, foi necessário incluir um controle para deixar de
realizar algumas funcionalidades quando o ambiente de execução for o móvel. O
Quadro 1 demonstra o comparador introduzido nos projetos para contornar o
escopo de código JavaFX Script, que causaram bugs em tempo de execução:
... if ("{__PROFILE__}" != "mobile"){ ...código não suportado atualmente no JavaFX Mobile… } ...
Quadro 1. Controle contra travamentos.
33
3.1. Primeiro Projeto
Como primeiro exemplo, o “Alô Mundo!”, o objetivo inicial foi a simplicidade
do código, sendo desenvolvido sob o perfil comum do JavaFX, afim de permitir sua
execução nos ambientes desktop, web ou dispositivos móveis.
A aplicação consiste em uma janela, contendo somente dois componentes:
um rótulo e um botão, ambos com alinhamento centralizado tendo como referência a
largura da tela, demonstrando uma das técnicas de leiaute aliado ao recuso de bind.
No evento do clique do botão é exibida uma caixa de dialogo com mensagem “Alô
Mundo!”, concatenado com o extenso da data atual. Neste exemplo é ilustrado uma
prévia do forte relacionamento com a linguagem Java, através da utilização do
objeto Java, representado pela a classe java.util.Date instanciada dentro do código
JavaFX Script, conforme é apresentado no Quadro 2 . O código completo pode ser
visto no (APÊNDICE A).
… importação de bibliotecas omitidas Stage { title: "Primeiro Projeto" var cena: Scene = Scene { fill: Color.AQUAMARINE width: 250 height: 250 var vbox: VBox content: [ vbox = VBox { spacing: 20 nodeHPos: HPos.CENTER layoutX: bind (cena.width - vbox.layoutBounds.width) /2 content: [Text { font: Font.font("Arial", FontWeight.BOLD, 20) content: "JavaFX" } Button { text: "Botão" action: function () { if ("{__PROFILE__}" != "mobile"){ var dataAtual = new Date(); Alert.inform("Informação", "Alô Mundo! {dataAtual}"); } } } ] } ] }
34
scene : cena }
Quadro 2. Código fonte do Primeiro Projeto
Neste exemplo não foi utilizado o recurso de formatação de data, tal como a
utilização da máscara “DD/MM/YYYY” (dia, mês e ano), visando à portabilidade
entre as plataformas. No ambiente mobile a formatação não é suportada.
Na Figura 1 é apresentada o conteúdo em tela executado na plataforma
desktop. O mesmo resultado é obtido quando submetido como applet, porém
incorporado ao navegador.
Figura 1. Primeiro Projeto
Na plataforma móvel, executado no simulador, tal como pode ser observado
na Figura 1 , um defeito relacionado a acentuação foi identificado. No rótulo “botão”,
o caractere “ã” não foi reconhecido. O mesmo problema foi observado no artigo de
Osvaldo Pinali DOEDERLEIN, que demonstrava a execução de sua aplicação em
plataformas distintas (DOEDERLEIN, 2009b).
35
Ainda sobre o erro de caracteres acentuados, felizmente, o exemplo ao ser
implantado e testado em um dispositivo real, o problema não ocorreu. O fato sugeriu
indícios de tratar-se de apenas um possível bug isolado relacionado ao simulador. O
resultado deste teste pode ser visto na Figura 2 :
Figura 2. Primeiro Projeto sob os dispositivos HTC
3.2. Projeto Calculadora
Neste exemplo foi elaborado um projeto de uma calculadora simplificada que
contém somente os operadores básicos aritméticos, ou seja, apenas possui as
operações de soma, subtração, multiplicação e divisão.
O escopo do programa é composto por um campo de texto para exibição
dos números digitados, bem como apresentação os resultados obtidos após o
cálculo; por seguinte, foi incluído um teclado numérico com seus respectivos
operadores, composto por um conjunto de botões da palheta de componentes do
perfil comum.
A interface foi desenvolvida sob o padrão de projeto MVC com o propósito
inicial de demonstrar a interação entre desenvolvedores e artistas gráficos,
utilizando-se do software Corel Draw para exportação da interface no formato SVG.
O resultado foi negativo devido a geração inadequada dos identificadores de objetos
agrupados, após a importação e conversão para o formato FXZ com o aplicativo
36
“SVG to JavaFX Graphics Converter”. Assim, devido à falta de conhecimento nas
ferramentas gráficas indicadas, como o Adobe Illustrator ou Photoshop, não foi
possível seguir adiante.
Avaliando o código fonte analisando-se o desempenho, foram identificados
certos abusos com relação a instanciação de muitos objetos com finalidade de
tratamento dos eventos de teclado. Porém visualmente, não causaram problemas
de performance no programa, mesmo nos dispositivos móveis.
A interface do programa pode ser vista na Figura 3 que demonstra a
execução nos dispositivos HTC.
Figura 3. Projeto Calculadora nos dispositivos HTC
3.2.1. Integração com Java
Visando a integração direta com o Java, os principais métodos foram
separados em um outro projeto e implementados em uma classe Java, nomeada
como “Calculadora” (APÊNDICE B). A classe, representando o modelo de negócio,
implementou a lógica dos operadores. Também neste projeto Java foi incluído um
tipo enumerado chamado de “Operação”, possuindo os tipos “SOMA”,
“SUBTRACAO”, “MULTIPLICACAO” e “DIVISAO”, para relacionar os operadores
nas comparações.
37
No Quadro 3 é exibida a classe Java “Calculadora” pelo o qual implementa
os métodos aritméticos:
package calculadora; public class Calculadora { public Double soma(Double x, Double y) { return x + y; } public Double subtrai(Double x, Double y) { return x - y; } public Double multiplica(Double x, Double y) { return x * y; } public Double divide(Double x, Double y) { return x / y; } }
Quadro 3. Classe Java Calculadora
Como complemento, a classe “InterfacePadraoView” implementa a interface
padrão do aplicativo, ilustrando a utilização de parte dos gerenciadores de leiaute
atualmente disponíveis, o Vbox, Hbox e Tile para alinhamento e posicionamento dos
botões na forma de um teclado numérico, tal como pode ser observado no Quadro
4.
.. def numerosDe1a9 = ["7", "8", "9", "4", "5", "6", "1", "2", "3"]; ... HBox { content: [ VBox { content: [ Tile { columns: 3 rows: 3 tileHeight: tamanhoBotao tileWidth: tamanhoBotao vgap: 1 hgap: 1 content: [ for (numero in numerosDe1a9) { Button { text: numero id: "id{numero}" onMouseClicked: controller.onMouseClickedBotaoNumerico onKeyPressed: controller.onKeyPressedCalculadora; } } ] } ...
Quadro 4. Trecho de código da classe InterfacePadr aoView
38
Com relação ao uso de objetos Java no contexto da linguagem JavaFX, na
classe “Controller” (APÊNDICE C) foram adicionados referências para exemplificar
este recurso. A propriedade privada “calculadora”, equivalente ao conceito de
atributo na linguagem Java, demonstra a utilização da instância da classe Java
“Calculadora”. Enquanto a função pública “calcula()” exibe o relacionamento dentre
objetos Java e JavaFX, bem como, a manipulação dos tipos enumerados dentro do
código, conforme pode ser observado no trecho de código do Quadro 5 .
... var calculadora: Calculadora; ... public function calcula(): Double { return if (operador == Operacao.SOMA) { calculadora.soma(op1, op2); } else if (operador == Operacao.SUBTRACAO) { calculadora.subtrai(op1, op2); } else if (operador == Operacao.MULTIPLICACAO) { calculadora.multiplica(op1, op2); } else if (operador == Operacao.DIVISAO) { calculadora.divide(op1, op2); } else { 0 } } ...
Quadro 5. Trecho de código da classe Controller
Outro ponto de destaque é a possibilidade do uso da API de Collections do
Java, tal como a interface Map e o HashMap, sendo inclusive disponível dentro do
ambiente mobile.
O resultado em tela obtida no ambiente desktop é apresentado na Figura 4 :
39
Figura 4. Calculadora
3.3. Projeto Agenda
O projeto foi baseado no aplicativo MVC demonstrado no artigo por Osvaldo
Pinali DOEDERLEIN, que apresentou uma implementação de um CRUD (Create,
read, update and delete), como um cadastro de produtos, contendo os recursos de
persistência de dados e a exibição dos resultados na forma de gráficos
(DOEDERLEIN, 2009b).
Contudo, no exemplo codificado neste trabalho, o conteúdo da aplicação é
de uma agenda, consistindo em um simples cadastro de contatos, com seus
respectivos nome e telefone. Neste, foram incluídos todos os itens ilustrados por
DOEDERLEIN, com exceção do gráfico de barras, e a introdução de outros novos
recursos, como a integração com servidor remoto e o uso de internacionalização
(DOEDERLEIN, 2009b).
Em resumo, o software proposto é composto por dois módulos, formando
uma arquitetura cliente-servidor. O cliente foi desenvolvido na plataforma JavaFX,
enquanto o servidor com a linguagem Java.
No ambiente mobile, nos dispositivos reais, a interface obtida é apresentada
na Figura 5 :
40
Figura 5. Projeto Agenda sob os dispositivos HTC
Infelizmente em razões de restrições de segurança derivados do sandbox,
devido ao uso de código considerado não confiável com a classe
javafx.io.http.HttpRequest, o projeto deste exemplo não pode ser executado no
ambiente web, tanto como applet ou webstart. O aplicativo somente poderia possuir
os devidos privilégios de execução a menos que fosse assinado digitalmente.
3.3.1. Lado servidor
O servidor trata-se de uma aplicação web que tem como objetivo produzir
um conteúdo no formato XML, simulando um serviço RESTFUL. Neste contexto, o
serviço remoto é invocado na inicialização do programa somente quando a lista de
contatos estiver vazia, gerando um conjunto de quatro registros fixos com números
de DDD e telefones aleatórios. O resultado é apresentado no Quadro 6 :
<?xml version="1.0" encoding="UTF-8"?> <contatos> <contato id="1261416750441" nome="Márcio" ddd="87" telefone="99065210"/> <contato id="1261416750456" nome="Contato 1" ddd="31" telefone="99045847"/> <contato id="1261416750490" nome="Contato 2" ddd="97" telefone="99088568"/> <contato id="1261416750500" nome="Contato 3" ddd="35" telefone="99058658"/> </contatos>
Quadro 6. Conteúdo XML retornado pelo servidor
41
3.3.2. Lado cliente
A interface do cliente é basicamente composta pela interação de duas telas,
uma para listagem dos contatos já cadastrados, e outra para manutenção e
inserção de novos registros. Na primeira tela, além de um componente de listagem,
contém no rodapé com três outros botões: incluir, alterar e excluir. No formulário de
edição (manutenção) possuem os campos de nome, DDD e telefone, seguido no
canto inferior os botões: salvar, cancelar e excluir.
Nos testes preliminares foram constatadas que após algumas interações de
telas no simulador da plataforma móvel, ocorreu o erro
java.lang.OutOfMemoryError, evidenciando a falta de memória para a criação de
novos objetos. O problema decorreu devido a alocação de memória para cada troca
de tela, ou seja, na interação entre as duas interfaces. A alteração na classe
“Controller”, para manter apenas uma instância para cada objeto da view,
solucionou o erro.
O conteúdo de interface pode ser visualizado na Figura 6 no perfil desktop:
Figura 6. Agenda
3.3.3. Internacionalização
A aplicação necessitou ser dividida em dois projetos, em razão da
compatibilidade com a plataforma mobile, visando a apresentação do recurso de
internacionalização, inexistente no perfil móvel. Deste modo foram construídas duas
42
aplicações idênticas, uma com o uso da internacionalização e outra não.
Infelizmente devido a bugs encontrados no IDE Netbeans, não foi possível
compartilhar as classes utilizadas em comum a ambos os projetos, sendo
necessário duplicar-las em cada projeto.
A internacionalização é o processo de extração literal, visível ao usuário, a
partir de um programa escrito em uma língua ou cultura, para ser traduzido para
outras línguas e culturas. A localização é o processo se de traduzir um programa
internacionalizado em um ou em vários idiomas específicos ou culturas. O JavaFX
possui ambos os mecanismos, de internacionalização quanto de localização, de
formas simples para o uso (WEAVER, 2009).
Deste modo, no JavaFX o mapeamento é feito através de um arquivo de
internacionalização com a extensão .fxproperties, que deve ser associado a sua
respectiva classe. O formato do nome do arquivo deve obedecer a uma regra: nome
da classe somado a língua seguido do país, separados pelo carácter “_”. A título de
exemplo, no caso da classe ManutencaoContatoView, o recipiente destinado para a
linguagem inglês e país Estados Unidos, foi nomeado como
“ManutencaoContatoView_en_US.fxproperties”.
O conteúdo do arquivo fxproperties demonstra o mapeamento realizado,
conforme pode ser observado no Quadro 7 :
"Manutenção contato" = "Maintaining contact" "Nome" = "Name" "Telefone" = "Phone" "Salvar" = "Save" "Cancelar" = "Cancel" "Excluir" = "Delete" "Cancelar Operação" = "Do you really want to cancel the operation?"
Quadro 7. Arquivo ManutencaoContatoView_en_US.fxpro perties
Os literais que servem como chave ao mapeamento, são referenciados
dentro do código JavaFX recebendo uma sintaxe especial, seguindo o formato
##[<chave>], conforme apresentado no trecho de código extraído da classe
“ManutencaoContatoView” (APÊNDICE D) no Quadro 8 :
43
... Button { text: ##[Cancelar]"Cancelar" layoutInfo: LayoutInfo {width: larguraBotao}; action: function () { if (Alert.question("Aviso", ##[Cancelar Operação]"Deseja realmente cancelar a operação?")) { controller.moveTelaLista(); } } } ...
Quadro 8. Trecho de código da classe ManutencaoCont atoView
3.3.4. Persistência de dados
A persistência dos dados foi obtida através da classe javafx.io.Storage. Com
o uso desta API, cada aplicação possui separadamente seu espaço compartilhado,
com o acesso exclusivo, permitindo a execução do aplicativo mesmo quando
submetidos em ambientes considerados como programas não confiáveis. Os dados
podem permanecem armazenados até que sejam explicitamente excluídos ou
quando a aplicação é desinstalada (SUN, 2009k).
O Quadro 9 apresenta uma partição da classe “BaseDeDados” (APÊNDICE
E), que demonstra a o carregamento em memória na forma de uma sequência, os
registro previamente persistidos em disco.
... storage = Storage {source: source}; def is = storage.resource.openInputStream(); def dis = new DataInputStream(is); var contatos: Contato[]; try { def qtdeRegistros: Integer = dis.readInt(); contatos = for (i in [1..qtdeRegistros]) { Contato { id: dis.readLong() nome: dis.readUTF() ddd: dis.readInt() telefone: dis.readInt() } } is.close(); } catch (ex: IOException) { ex.printStackTrace(); }...
Quadro 9. Trecho de código da classe BaseDeDados
44
3.3.5. Integração
A integração com o servidor remoto foi realizada basicamente por meio da
chamada do serviço e consumo do conteúdo XML retornado, com o objetivo de
ilustrar o uso hipotético de um Web Service RESTful.
A classe javafx.io.http.HttpRequest é a API responsável pela requisição
HTTP (Hyper Text Transfer Protocol) assíncrona, utilizada também para a invocação
de Web Services RESTful (SUN, 2009m).
Para a interpretação das informações recebidas foi utilizado um analisador
de dados estruturados (parser) proveniente da classe javafx.data.pull.PullParser,
que fornece uma sequência de eventos para o processamento do documento sob o
controle do aplicativo. Atualmente possui o suporte para os formatos XML e a JSON
(JavaScript Object Notation) (SUN, 2009n).
Por fim, a classe “RequisicaoServidor” (APÊNDICE F) foi implementada
utilizando as APIs anteriormente citadas, com a finalidade de realizar uma
solicitação remota, e decodificar e persistir os dados recebidos pelo servidor, tal
como pode ser observado no trecho de código do Quadro 10 :
... HttpRequest { location: urlServidor onInput: function (inputStream: InputStream) { var contato: Contato; try { var parser: PullParser = PullParser { input: inputStream documentType: PullParser.XML onEvent: function (e: Event) { if ( e.type == PullParser.START_ELEMENT and e.qname.name == "contato") { contato = Contato { id: Long.parseLong(e.getAttributeValue("id")) nome: e.getAttributeValue("nome") ddd: Integer.parseInt(e.getAttributeValue("ddd")) telefone: Integer.parseInt(e.getAttributeValue("telefone")) } agendaDao.salvarOuAtualizaContato(contato); } } }
45
... Quadro 10. Trecho de código da classe RequisicaoSe rvidor
Nos testes realizados nos dispositivos móveis, o recurso de integração
funcionou no ambiente real. Os registros foram devidamente importados e
persistidos após executar o download do conteúdo XML, disponibilizado em servidor
na Internet.
Neste exemplo, o redimensionamento automático das telas não foi
implementado, por questões de simplicidade. Logo, a altura da interface necessitou
ser readequada após ser testado no HTC P4351, pelo o qual possui o tamanho de
tela inferior ao do simulador. Já no HTC Diamond, cuja resolução é muito maior, a
tela ocupou somente uma pequena parte do espaço disponível em tela.
Em resumo, foi constatado um problema de desempenho no HTC P4351, na
interação dentre as telas de listagem e manutenção dos registros. No HTC
Diamond, pelo o qual possui praticamente o dobro de recursos computacionais em
comparação ao modelo P4351, o tempo de resposta foi bem menor, garantindo
assim, maior performance.
No decorrer dos testes, o programa apresentou alguns problemas com a
persistência de informações, tanto na leitura quanto na escrita dos dados, quando
executado no simulador padrão da plataforma móvel. O defeito encontrado indicou o
corrompimento do arquivo que armazenava as informações, que causava
instabilidades no processo de carregar ou descarregar os dados. A solução adotada
foi excluir manualmente o arquivo de persistência, no caso do exemplo da Agenda,
o caminho foi localizado no C:\Users\<<nome do usuário>>\javafx-sdk\1.2-
b31\work\0\appdb\filesystem\root1\javafxStore\muffin.
Como citado inicialmente, no ambiente Windows Mobile, ocorreram
problemas em tempo de execução relacionadas as mensagens de alertas,
informativas ou exclamativas, derivadas da classe javafx.stage.Alert. Tais
problemas causaram um erro crítico na aplicação, travando inclusive o runtime e o
JVM do JavaFX; sendo assim, somente finalizando manualmente o processo do
JVM foi possível restaurar-lo. Como o problema persistiu em ambos os dispositivos
46
HTC testados, tal fato sinalizou um possível bug, ainda não catalogado
formalmente.
47
4. CONCLUSÕES E TRABALHOS FUTUROS
Sendo um dos primeiros trabalhos focados na nova tecnologia JavaFX,
houveram certas dificuldades correlacionadas a obtenção dos materiais e artigos,
embora muitos destes estejam disponíveis como textos oficiais fornecidos pelo
fabricante, o conteúdo ainda apresentou-se muito disperso.
A escassez de trabalhos científicos relacionados ao tema, evidenciou a
necessidade de uma ênfase maior no contexto teórico, logo, tomando grande parte
dos esforços aplicados nesta pesquisa.
O trabalho se concentrou na visão geral até a versão JavaFX 1.2, excluindo
a versão 1.2.1, pelo o qual foi lançado após o término da revisão bibliográfica.
Com relação ao ambiente de desenvolvimento, o IDE Netbeans, adotado
como a ferramenta para a implementação dos exemplos abordados, apresentou-se
ainda pouco maturo, apresentando algumas falhas de recursos básicos do editor,
instabilidades no IDE, dentre outros bugs. No contexto do trabalho, no entanto, não
foram catalogados todos os problemas encontrados.
Em virtude do IDE Netbeans versão 6.8, o último release disponível,
apresentar instabilidades em comparação a sua versão anterior, a 6.7.1, como
defeitos no reconhecimento de classes de bibliotecas de terceiros (por exemplo o
JFXtras), e erros de compilação, ambas as versões, 6.7.1 e 6.8, foram utilizadas em
conjunto para contemplar a implementação dos projetos. Tal fato é justificado
devido as vantagens presentes na nova versão, tendo como destaque o visualizador
prévio da interface a ser gerada, a complementação do código, e dentre outras
melhorias que facilitaram no desenvolvimento dos exemplos.
Do ponto de vista técnico, foram confirmadas muitas semelhanças com a
linguagem Java, como classes, tipos de dados, sintaxe em geral, dentre outras -
tendo em especial - a capacidade de integração com a mesma. Além disso, o uso de
sintaxes declarativas demonstrou que realmente podem promover agilidade no
desenvolvimento de interfaces ricas.
Outro ponto de destaque é o reconhecimento do considerável potencial da
linguagem, através dos recursos de bind, triggers e sintaxes baseadas no SQL, que
48
utilizadas adequadamente, podem simplificar o processo de implementação de
controles sincronizados com componentes em tela.
Também como fatores importantes foram satisfatórios o desempenho nas
plataformas web e desktop, as formas disponível para implantação de aplicativos na
Internet, e a interação dentre desenvolvedores e artistas através do uso de plugins
para ferramentas gráficas. A segurança herdada do Java, o sandbox pode ser
citado como um dos pontos fundamentais para a implantação remota de aplicações,
garantindo integridade e segurança dos softwares distribuídos pela rede de
computadores.
Quanto a API, como retratado por DODERLEIN, a palheta de componentes
ainda deixaram a desejar, mesmo com a utilização dos controles nativos estendidos
do Swing, ainda podem não apresentar um “arsenal” completo para o
desenvolvimento de interfaces (DOEDERLEIN, 2009a). No entanto, nos perfis
desktop e web, para suprir tais necessidades, é possível realizar a extensão
manualmente de componentes Swing e/ou a incorporação de frameworks de
terceiros, contudo, podendo abdicar de algumas das facilidades da linguagem
declarativa.
Os gerenciadores de leiautes atualmente disponíveis, ainda podem ser
considerados muito simples para construção de interfaces mais complexas, mesmo para o
controle de simples formulários, podem exigir um esforço considerável para o
posicionamento manual e alinhamento dos componentes. Para tanto, para as plataformas
desktop e mobile, é possível também contornar esta deficiência por meio de bibliotecas de
terceiros.
O uso do JavaFX, em primeiro momento, pode não ser indicado para a
implementação de aplicações comerciais de médio ou grande porte. Pode ser
evidente o risco de novas atualizações que promovam alterações na API, ou na
linguagem JavaFX Script, que embora possam aprimorar ou corrigir possíveis falhas
de arquitetura, podem causar impactos indesejáveis na manutenção de um sistema
que já esteja em produção.
A versão atual JavaFX 1.2, ainda pode não ser considerado competitivo
como seus concorrentes, FLEX ou Silverlight, por ausência de alguns recursos
chaves tais como: completos componentes de controle, ambiente de
49
desenvolvimento visual - essencial para a adesão de leiautistas, e por fim, a falta de
IDEs mais estáveis.
Embora não divulgado formalmente, o próprio compilador ainda pode estar
no estágio beta, conforme pode ser observado em algumas nomenclaturas dos
diretórios do SDK referenciados pelo IDE Netbeans, como exemplo o “1.2-b31” e
“1.2-b603”, que representam respectivamente o JavaFX 1.2 e 1.2.1. Tal indício pode
indicar que o estagio de evolução possivelmente ainda está em testes, portanto a
presença de bugs e instabilidades no ambiente de desenvolvimento, poderiam ser
aceitáveis.
Por fim é importante ressaltar que o presente trabalho focou o JavaFX até o
release 1.2, e versões posteriores a serem lançadas, como o JavaFX 1.3, podem
prometer a inclusão de novos componentes gráficos, gerenciadores de leiaute,
dentre outras melhorias, tais como aprimoramento de desempenho, maior
estabilidade, ambiente de desenvolvimento visual com o lançamento da ferramenta
JavaFX Authoring Tool, além da integração com outras novas plataformas, como
televisores e dispositivos embarcados.
Com trabalhos futuros para a presente pesquisa, é proposto:
• Avaliar a performance dos aplicativos JavaFX através de implementação de
programas focados em testes de desempenho, enfatizando comparações
com seus concorrentes.
• Efetuar estudos sobre a arquitetura do compilador, bem como o mapeamento
de seus principais componentes, com o objetivo de apresentar o
funcionamento e os conceitos envolvidos - explorando suas vantagens e
desvantagens.
• Aprofundar nos conhecimentos na Linguagem JavaFX Script, analisando todo
seu contexto, e a suas melhores práticas. Realizar comparações com outras
linguagens RIAs similares, abordando seus principais aspectos positivos e
negativos.
50
5. REFERÊNCIAS
[ADOBE, 2009] Visão geral do Flex. Disponível em: <http://www.adobe.com/br/products/flex/overview>. Acesso em 30 de nov. de 2009. [ALLAIRE, 2002] ALLAIRE, Jeremy. Macromedia Flash MX—A next-generation rich client. Disponível em: <http://download.macromedia.com/pub/flash/whitepapers/richclient.pdf>. Acesso em 25 de nov. de 2009. [AUSTIN, 1999] AUSTIN, Calvin; PAWLAN, Monica. Advanced Programming for the Java 2 Platform: Chapter 10: Signed Applets Disponível em: <http://java.sun.com/developer/onlineTraining/Programming/JDCBook/signed.html>. Acesso em 03 de jan. de 2010. [BAIR, 2009] BAIR Richard. Skinning Architecture in JavaFX. Disponível em: <http://fxexperience.com/2009/06/skinning-architecture-in-javafx/>. Acesso em 30 de nov. de 2009. [BOZZON, 2006] BOZZON, Alessandro; FRATERNALI, Piero; COMAI, Sara; CARUGHI, Giovanni Toffetti. Conceptual Modeling and Code Generation for Rich Internet Applications. Disponível em: <http://portal.acm.org/citation.cfm?id=1145581.1145649&coll=GUIDE&dl=GUIDE&CFID=4422105&CFTOKEN=26041127 >. Acesso em 5 de ago. de 2009. [CASTILLO, 2009] CASTILLO, Cindy. Deploy A Rich Internet Application Developed With JavaFX Technology. Disponível em: <http://javafx.com/docs/tutorials/deployment/>. Acesso em 15 de nov. de 2009. [CHO, 2009] CHO, Inyoung. JavaFX 1.2 Technology: Features and Enhancements. Disponível em: <http://javafx.com/docs/articles/javafx1-2.jsp>. Acesso em out. de 2009. [CHOUDHARY, 2009] CHOUDHARY, Vaibhav; HILDEBRANDT, Nancy. JavaFX Applets in the Browser: Learn best practices for deploying JavaFX applications as applets in a browser Disponível em: <http://javafx.com/docs/tutorials/deploy-applet/>. Acesso em 10 de jan. de 2010. [DOEDERLEIN, 2009a] DOEDERLEIN, Osvaldo Pinali. JavaFX: RIA a todo vapor – Apresentando a JavaFX 1.0 e JavaFX Mobile. Java Magazine. Rio de Janeiro: DevMedia Group, v.7, n.67, p. 50-60, mar.. 2009. [DOEDERLEIN, 2009b] DOEDERLEIN, Osvaldo Pinali. Uma “Aplicação Comum” em JavaFX: JavaFX não é só para multimídia e efeitos gráficos. Java Magazine. Rio de Janeiro: DevMedia Group, v.7, n.72, p. 50-60, set. 2009.
51
[HOMMEL, 2009] HOMMEL, Scott. Lesson 1: Getting Started with JavaFX Script. Disponível em: <http://java.sun.com/javafx/1/tutorials/core/getStarted> Acesso em 13 de nov. de 2009. [KOSTOVAROV, 2009] KOSTOVAROV, Dmitry. Create a Secure JavaFX Application. Disponível em: <http://javafx.com/docs/techtips/Create-Secure-JavaFX-App/index.jsp>. Acesso em 7 de jan. de 2010. [KRILL, 2008] KRILL, Paul. Java SE 6u10 to solve JRE and Java application deployment issues. Disponível em: <http://www.javaworld.com/javaworld/jw-09-2008/jw-09-6u10.html?page=1>. Acesso em 3 de nov. de 2009. [LINAJE, 2008] LINAJE, Marino; PRECIADO, Juan Carlos; MORALES-CHAPARRO, Rober; SANCHEZ-FIGUEROA, Fernando. On the Implementation of Multiplatform RIA User Interface Components. Disponível em: <http://sunsite.informatik.rwth-aachen.de/Publications/CEUR-WS/Vol-445/02icwe2008ws-iwwost08-linaje.pdf>. Acesso em 3 de set. de 2009. [MALENKOV, 2009] MALENKOV, Sergey. Weather on SunTechDays. Disponível em: <http://weblogs.java.net/blog/malenkov/archive/2009/04/weather_on_sunt.html>. Acesso em 20 de dez. de 2009. [MAREJKA, 2007] MAREJKA, Richard. JavaFX Mobile - A Little Thing, A Big Step. Disponível em: <http://java.sun.com/javaone/sf/2007/articles/javafxmobile.jsp>. Acesso em out. de 2009. [MORONEY, 2007] MORONEY, Laurence. Introdução ao Silverlight. Disponível em: <http://msdn.microsoft.com/pt-br/library/cc580591.aspx>. Acesso em 30 de nov. de 2009. [NICHOLAS, 2008] NICHOLAS, Ethan. Introducing Java SE 6 update 10. Disponível em: <http://java.sun.com/developer/technicalArticles/javase/java6u10>. Acesso em 17 de out. de 2009. [OLIVER, 2006] OLIVER, Christopher. F3. Disponível em: <http://blogs.sun.com/chrisoliver/entry/f3>. Acesso em out. de 2009. [OLIVER, 2007] OLIVER, Christopher. Welcome. Disponível em: <https://openjfx.dev.java.net/servlets/ReadMsg?list=dev&msgNo=26>. Acesso em 26 de out. de 2009. [OLIVER, 2009] OLIVER, Christopher. From F3 to JavaFX 1.0 - Effects. Disponível em: <http://blogs.sun.com/chrisoliver/entry/from_f3_to_javafx_1>. Acesso em out. de 2009. [O'NEILL, 2007] O'NEILL, Leslie T.. Create rich content applications for mobile, set-top, and desktop devices with JavaFX. Disponível em: <http://www.sun.com/featured-articles/2007-
52
0508/javafx/index.jsp?intcmp=hp2007may08_javafx_read>. Acesso em 17 de out. de 2009. [OpenFX, 2009a] OpenFX Project Home. Disponível em: <https://openjfx-compiler.dev.java.net>. Acesso em 30 de nov. de 2009. [OpenFX, 2009b] Embeded SQL or LINQ support. Disponível em: <http://jfx.wikia.com/wiki/Embeded_SQL_or_LINQ_support>. Acesso em 30 de nov. de 2009. [O'ROURKE, 2004] O'ROURKE, Cameron. A Look at Rich Internet Applications. Disponível em: <http://wolfpaulus.com/theodore/doc/richinetapp.pdf>. Acesso em 20 de ago. de 2009. [SUN, 2007a] Sun Radically Simplifies Content Authoring - Previews JavaFX Script. Disponível em: <http://www.sun.com/aboutsun/pr/2007-05/sunflash.20070508.2.xml>. Acesso em out. de 2009. [SUN, 2007b] Sun Welcomes SavaJe Technologies. Disponível em: <http://www.sun.com/software/savaje/index.xml>. Acesso em out. de 2009. [SUN, 2007c] Sun Unveils Mobile Software at JavaOne Conference Attended By 15,000 Developers. Disponível em: <http://www.sun.com/aboutsun/pr/2007-05/sunflash.20070508.6.xml>. Acesso em 10 de out. de 2009. [SUN, 2007d] JNLP Support in the New Java™ Plug-In Technology. Disponível em: <https://jdk6.dev.java.net/plugin2/jnlp/>. Acesso em 8 de jan. de 2010. [SUN, 2008a] Sun Microsystems Unveils JavaFX 1.0 with Immersive Media Capabilities Targeted at Market's 800 Million Java Powered Desktops. Disponível em: <http://www.sun.com/aboutsun/pr/2008-12/sunflash.20081204.1.xml>. Acesso em 12 de out. de 2009. [SUN, 2008b] JavaTM SE 6 Update Release Notes. Disponível em: <http://java.sun.com/javase/6/webnotes/6u10.html>. Acesso em 17 de out. de 2009. [SUN, 2009a] Sun Microsystems JavaFX web site. Disponível em: <http://www.sun.com/software/javafx>. Acesso em out. de 2009. [SUN, 2009b] [Sun Releases New Java and JavaFX Software Updates and Previews JavaFX TV; Strong Demand Powers 250 Million JavaFX Downloads. Disponível em: <http://www.sun.com/aboutsun/pr/2009-06/sunflash.20090602.3.xml>. Acesso em out. De 2009. [SUN, 2009c] JavaFX | Rich Internet Applications Development | RIAs Java FX. Disponível em: <http://javafx.com>. Acesso em out. de 2009.
53
[SUN, 2009d] JavaFX Script – Overview. Disponível em: <http://www.sun.com/software/javafx/script/index.jsp>. Acesso em 17 de out. de 2009. [SUN, 2009e] Software and System Requirements for JavaFX Technology. Disponível em: <http://java.sun.com/javafx/1/reference/system-requirements-1-2.html>. Acesso em 3 de nov. de 2009. [SUN, 2009f] JavaFX 1.1 Production Suite Release Notes. Disponível em: <http://java.sun.com/javafx/1/reference/releasenotes/production-suite-release-notes-1-1.html>. Acesso em 5 de nov. de 2009. [SUN, 2009g] OEM Early Access. Disponível em: <http://www.sun.com/oem/eda.jsp>. Acesso em 7 de nov. de 2009. [SUN, 2009h] Integrate Graphic Assets Into Your JavaFX. Application. Disponível em: <http://javafx.com/docs/integrate-graphic-assets>. Acesso em 30 de nov. de 2009. [SUN, 2009i] JavaFX Graphics Files (FXZ, FXD). Disponível em: <http://javafx.com/docs/integrate-graphic-assets/Fileformats.jsp>. Acesso em 30 de nov. de 2009. [SUN, 2009j] General Questions. Disponível em: <http://javafx.com/faq/>. Acesso em 10 de agos. de 2009. [SUN, 2009k] JavaFX 1.2.1 API, javafx.io.Storage. Disponível em: <http://java.sun.com/javafx/1.2/docs/api/javafx.io/javafx.io.Storage.html>. Acesso em 5 de jan. de 2010. [SUN, 2009l] JavaFX™ Mobile 1.2 for Windows Mobile OS Release Notes. Disponível em: <http://www.javafx.com/downloads/mobile/ReleaseNotes.pdf>. Acesso em 25 de nov. de 2009. [SUN, 2009m] JavaFX 1.2.1 API, javafx.io.http.HttpRequest. Disponível em: <http://java.sun.com/javafx/1.2/docs/api/javafx.io.http/javafx.io.http.HttpRequest.html>. Acesso em 15 de dez. de 2009. [SUN, 2009n] JavaFX 1.2.1 API, javafx.data.pull.PullParser. Disponível em: <http://java.sun.com/javafx/1.2/docs/api/javafx.data.pull/javafx.data.pull.PullParser.html>. Acesso em 15 de dez. de 2009. [SUN, 2009o] Signing and Verifying JAR Files. Disponível em: <http://java.sun.com/docs/books/tutorial/deployment/jar/signindex.html>. Acesso em 11 de jan. de 2010. [WEAVER, 2009] WEAVER, James L.; GAO, Weiqi; CHIN, Stephen; IVERSON, Dean. Pro JavaFX™ Platform: Script, Desktop and Mobile RIA with Java™ Technology. Berkeley: Apress, 2009. 544 p.
54
[ZUKOWSKI, 2002] ZUKOWSKI, John. Deploying Software with JNLP and Java Web Start. Disponível em: <http://java.sun.com/developer/technicalArticles/Programming/jnlp/>. Acesso em 15 de set. de 2009.
55
6. BIBLIOGRAFIA CONSULTADA
[1] HOMMEL, Scott. Learning the JavaFX Script Programming Language - Tutorial Overview. Disponível em: <http://java.sun.com/javafx/1/tutorials/core>. Acesso em 15 de agos. de 2009. [2] REDKO, Alla. Building GUI Applications With JavaFX. Disponível em: <http://java.sun.com/javafx/1/tutorials/ui/overview/index.html>. Acesso em 15 de dez. de 2009. [3] PILGRIM, Peter. Enterprise Java FX for the Web Platform. Disponível em: <http://www.infoq.com/presentations/Java-FX-Peter-Pilgrim>. Acesso em 21 de set. de 2009. [4] HEINRICHS, Michael. JavaFX Mobile Applications — Best Practices for Improving Performance. Disponível em: <http://java.sun.com/developer/technicalArticles/javafx/mobile/>. Acesso em 7 de jan. de 2010. [5] GALPIN, Michael. Creating mashups with JavaFX. Disponível em: <http://www.ibm.com/developerworks/web/library/wa-javafx/>. Acesso em 20 de dez. de 2009.
56
7. APÊNDICES
57
7.1. APÊNDICE A - Código Fonte do primeiro exemplo
package primeiroprojeto; import javafx.stage.Stage; import javafx.scene.Scene; import javafx.scene.text.Text; import javafx.scene.text.Font; import javafx.scene.control.Button; import javafx.scene.layout.VBox; import javafx.scene.paint.Color; import javafx.scene.text.FontWeight; import javafx.stage.Alert; import javafx.geometry.HPos; import java.util.Date; Stage { title: "Primeiro Projeto" var cena: Scene = Scene { fill: Color.AQUAMARINE width: 250 height: 250 var vbox: VBox content: [ vbox = VBox { spacing: 20 nodeHPos: HPos.CENTER layoutX: bind (cena.width - vbox.layoutBounds.width) /2 content: [Text { font: Font.font("Arial", FontWeight.BOLD, 20) content: "JavaFX" } Button { text: "Botão" action: function () { var dataAtual = new Date(); if("{__PROFILE__}" != "mobile") Alert.inform("Informação", "Alô Mundo! {dataAtual}"); } } ] } ] } scene : cena }
58
7.2. APÊNDICE B – Código fonte da classe InterfaceP adraoView
package view; import javafx.scene.Node; import javafx.scene.layout.VBox; import javafx.scene.control.Button; import javafx.scene.control.TextBox; import javafx.scene.layout.HBox; import javafx.scene.layout.LayoutInfo; import javafx.scene.layout.Tile; def tamanhoBotao = 50; def numerosDe1a9 = ["7", "8", "9", "4", "5", "6", "1", "2", "3"]; def operadoresCantoSuperior = ["/", "*", "-"]; public class InterfacePadraoView extends CalculadoraView { override protected function create(): Node { VBox { layoutX: 20 content: [ HBox { content: [TextBox { text: bind controller.textoDisplay columns: 12 editable: false layoutInfo: LayoutInfo {width: 203 height: 40} selectOnFocus: false } ] } Tile { columns: 4 rows: 1 tileHeight: tamanhoBotao tileWidth: tamanhoBotao vgap: 1 hgap: 1 content: [ Button { text: "C" id: "idC" styleClass: "botoesTecla" onMouseClicked: controller.onMouseClickedBotaoC onKeyPressed: controller.onKeyPressedCalculadora; }
59
for (operador in operadoresCantoSuperior) { Button { text: operador id: "id{operador}" onMouseClicked: controller.onMouseClickedBotaoOperador onKeyPressed: controller.onKeyPressedCalculadora; styleClass: "botoesTecla" } } ] } HBox { content: [ VBox { content: [ Tile { columns: 3 rows: 3 tileHeight: tamanhoBotao tileWidth: tamanhoBotao vgap: 1 hgap: 1 content: [ for (numero in numerosDe1a9) { Button { text: numero id: "id{numero}" styleClass: "botoesTecla" onMouseClicked: controller.onMouseClickedBotaoNumerico onKeyPressed: controller.onKeyPressedCalculadora; } } ] } HBox { spacing: 1 content: [ Button { layoutInfo: LayoutInfo {height: tamanhoBotao width: tamanhoBotao * 2} text: "0" id: "id0" styleClass: "botoesTecla" onMouseClicked: controller.onMouseClickedBotaoNumerico onKeyPressed: controller.onKeyPressedCalculadora; } Button {
60
layoutInfo: LayoutInfo {height: tamanhoBotao width: tamanhoBotao} text: "." styleClass: "botoesTecla" onMouseClicked: controller.onMouseClickedBotaoPonto onKeyPressed: controller.onKeyPressedCalculadora; } ] } ] } Tile { columns: 1 rows: 2 tileHeight: tamanhoBotao * 2 tileWidth: tamanhoBotao vgap: 2 hgap: 1 content: [ Button { text: "+" id: "id+" styleClass: "botoesTecla" onMouseClicked: controller.onMouseClickedBotaoOperador onKeyPressed: controller.onKeyPressedCalculadora; } Button { text: "=" id: "id=" styleClass: "botoesTecla" onMouseClicked: controller.onMouseClickedBotaoIgual onKeyPressed: controller.onKeyPressedCalculadora; } ] } ] } ] } } }
61
7.3. APÊNDICE C – Código fonte da classe Controller
package calculadorafx; import calculadora.Calculadora; import calculadora.Operacao; import javafx.scene.input.KeyEvent; import java.util.Map; import javafx.scene.input.KeyCode; import java.util.HashMap; import javafx.scene.input.MouseEvent; import java.lang.NumberFormatException; public class Controller { var op1: Double; var op2: Double; public-read var textoDisplay: String; var operador: Operacao; var calculadora: Calculadora; var mapaBotoesNumericos: Map; var mapaBotoesOperadores: Map; var mapaTeclasNumericas: Map; var mapaTeclasNumPad: Map; var mapaTeclasOperadores: Map; var isDecimal: Boolean; var operacaoSinalizada: Boolean = false; postinit { operador = null; calculadora = Calculadora {}; def numeros = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "0"]; def idsBotoesNumericos = ["id1", "id2", "id3", "id4", "id5", "id6", "id7", "id8", "id9", "id0"]; def idsBotoesOperadores = ["id+", "id-", "id*", "id/"]; def teclasNumericas = [KeyCode.VK_1, KeyCode.VK_2, KeyCode.VK_3, KeyCode.VK_4, KeyCode.VK_5, KeyCode.VK_6, KeyCode.VK_7, KeyCode.VK_8, KeyCode.VK_9, KeyCode.VK_0]; def teclasOperadores = [KeyCode.VK_ADD, KeyCode.VK_SUBTRACT, KeyCode.VK_MULTIPLY, KeyCode.VK_DIVIDE]; def operadores = Operacao.values(); def teclasNumPad = [KeyCode.VK_NUMPAD1, KeyCode.VK_NUMPAD2, KeyCode.VK_NUMPAD3, KeyCode.VK_NUMPAD4, KeyCode.VK_NUMPAD5, KeyCode.VK_NUMPAD6, KeyCode.VK_NUMPAD7, KeyCode.VK_NUMPAD8, KeyCode.VK_NUMPAD9, KeyCode.VK_NUMPAD0];
62
mapaBotoesNumericos = new HashMap(); mapaBotoesOperadores = new HashMap(); mapaTeclasNumericas = new HashMap(); mapaTeclasOperadores = new HashMap(); mapaTeclasNumPad = new HashMap(); for (i in [0..9]) { mapaBotoesNumericos.put(idsBotoesNumericos[i], numeros[i]); mapaTeclasNumericas.put(teclasNumericas[i], numeros[i]); mapaTeclasNumPad.put(teclasNumPad[i], numeros[i]); } for (i in [0..3]) { mapaBotoesOperadores.put(idsBotoesOperadores[i], operadores[i]); mapaTeclasOperadores.put(teclasOperadores[i], operadores[i]); } } public function calcula(): Double { return if (operador == Operacao.SOMA) { calculadora.soma(op1, op2); } else if (operador == Operacao.SUBTRACAO) { calculadora.subtrai(op1, op2); } else if (operador == Operacao.MULTIPLICACAO) { calculadora.multiplica(op1, op2); } else if (operador == Operacao.DIVISAO) { calculadora.divide(op1, op2); } else { 0 } } public function onMouseClickedBotaoC(e: MouseEvent): Void { textoDisplay = ""; isDecimal = false; operador = null; } public function onMouseClickedBotaoNumerico(e: MouseEvent): Void { controlaDisplay(mapaBotoesNumericos.get(e.node.id) as String); } function controlaDisplay(numeroDigitado: String) { if ("null".equals(numeroDigitado)) { return ; } if (operacaoSinalizada) {
63
textoDisplay = numeroDigitado; operacaoSinalizada = false; } else { textoDisplay += numeroDigitado; } } function onKeyPressedBotaoNumerico(e: KeyEvent): Void { var teclaPressionada = mapaTeclasNumericas.get(e.code) as String; teclaPressionada = if (teclaPressionada != null) "{teclaPressionada}" else "{mapaTeclasNumPad.get(e.code)}"; controlaDisplay(teclaPressionada); } function onKeyPressedBotaoOperador(e: KeyEvent): Void { def testeOperador: Operacao = mapaTeclasOperadores.get(e.code) as Operacao; if (testeOperador == null or textoDisplay.equals("")) { return ; } operador = testeOperador; sinalizaOperador(); } public function onKeyPressedCalculadora(e: KeyEvent): Void { this.onKeyPressedBotaoNumerico(e); this.onKeyPressedBotaoOperador(e); if (e.code == KeyCode.VK_DECIMAL) { this.onMouseClickedBotaoPonto(null); } else if (e.code == KeyCode.VK_ENTER) { this.onMouseClickedBotaoIgual(null); } } public function onMouseClickedBotaoOperador(e: MouseEvent): Void { if (textoDisplay.equals("")) { return ; }
64
operador = mapaBotoesOperadores.get(e.node.id) as Operacao; sinalizaOperador(); } function sinalizaOperador() { if (operador == null) { return ; } try { op1 = Double.parseDouble(textoDisplay); operacaoSinalizada = true; } catch (nfe: NumberFormatException) { operador = null; } } public function onMouseClickedBotaoPonto(e: MouseEvent): Void { if (not isDecimal) { isDecimal = true; if (textoDisplay.equals("")) { textoDisplay = "0"; } textoDisplay += "."; } } function reiniciar() { isDecimal = true; operador = null; } public function onMouseClickedBotaoIgual(e: MouseEvent): Void { if (operador == null) { return ; } try { op2 = Double.parseDouble(textoDisplay); } catch (nfe: NumberFormatException) { operador = null; return ; } textoDisplay = "{calcula()}"; reiniciar(); } }
65
7.4. APÊNDICE D – Código fonte da classe Manutenca oContatoView
package gui; import entidade.Contato; import javafx.scene.control.TextBox; import javafx.scene.layout.VBox; import javafx.scene.layout.HBox; import javafx.scene.control.Label; import javafx.scene.layout.Panel; import javafx.geometry.HPos; import javafx.scene.control.Button; import java.lang.NumberFormatException; import javafx.stage.Alert; import javafx.scene.layout.LayoutInfo; import javafx.geometry.VPos; import javafx.scene.text.Font; import javafx.scene.text.FontWeight; def larguraBotao = 70; public class ManutencaoContatoView extends AgendaView { public var contato: Contato on replace { inicializaTela(); } var tfNome: TextBox; var tfDdd: TextBox; var tfTelefone: TextBox; function inicializaTela() { tfNome.text = "{contato.nome}"; tfDdd.text = "{contato.ddd}"; tfTelefone.text = "{contato.telefone}"; } function salvar() { contato.nome = tfNome.text; try { contato.ddd = Integer.valueOf(tfDdd.text); contato.telefone = Integer.valueOf(tfTelefone.text); } catch (nfe: NumberFormatException) { Alert.inform("Erro", "Telefone Inválido"); } controller.salvar(contato);
66
} override def content = VBox { content: [ HBox { content: [ Label { layoutInfo: LayoutInfo {width: Controller.larguraTela, height: 50} text: ##[Manutenção contato]"Manutenção contato" font: Font.font("Arial", FontWeight.DEMI_BOLD, 18) hpos: HPos.CENTER } ] } Panel { layoutInfo: LayoutInfo {width: Controller.larguraTela height: 230} content: [ Label { layoutX: 8 layoutY: 4 text: ##[Nome]"Nome:" } tfNome = TextBox { layoutX: 69 layoutY: 4 text: "" columns: 14 selectOnFocus: false } Label { layoutX: 8 layoutY: 34 text: ##[Telefone]"Telefone:" } tfDdd = TextBox { layoutX: 69 layoutY: 34 text: "" columns: 2 selectOnFocus: true } tfTelefone = TextBox { layoutX: 119 layoutY: 34 text: "" columns: 8 selectOnFocus: true }
67
] } HBox { vpos: VPos.BOTTOM spacing: 10 content: [ Button { text: ##[Salvar]"Salvar" layoutInfo: LayoutInfo {width: larguraBotao}; action: function () { salvar(); } } Button { text: ##[Cancelar]"Cancelar" layoutInfo: LayoutInfo {width: larguraBotao}; action: function () { if (Alert.question("Aviso", ##[Cancelar Operação]"Deseja realmente cancelar a operação?")) { controller.moveTelaLista(); } } } Button { text: ##[Excluir]"Excluir" layoutInfo: LayoutInfo {width: larguraBotao}; action: function () { if (controller.remover(contato)) { controller.moveTelaLista(); } } } ] } ] } }
68
7.5. APÊNDICE E – Código fonte da classe BaseDeDado s
package persistencia; import entidade.Contato; import javafx.io.Storage; import java.io.DataInputStream; import java.io.IOException; import java.io.DataOutputStream; def source: String = "Agendas"; public class BaseDeDados { var storage: Storage; public function lerTodos(): Contato[] { if (Storage.list() == null) { return null; } storage = Storage {source: source}; def is = storage.resource.openInputStream(); def dis = new DataInputStream(is); def qtdeRegistros: Integer = dis.readInt(); var contatos: Contato[] = for (i in [1..qtdeRegistros]) { Contato { id: dis.readLong() nome: dis.readUTF() ddd: dis.readInt() telefone: dis.readInt() } } try { is.close(); } catch (ex: IOException) { ex.printStackTrace(); } return contatos; } public function salvar(contatos: Contato[]) { storage = Storage {source: source};
69
def os = storage.resource.openOutputStream(true); def dos = new DataOutputStream(os); try { dos.writeInt(sizeof contatos); for (c in contatos) { dos.writeLong(c.id); dos.writeUTF(c.nome); dos.writeInt(c.ddd); dos.writeInt(c.telefone); } dos.close(); } catch (ex: IOException) { ex.printStackTrace(); } } }
70
7.6. APÊNDICE F – Código fonte da classe Requisicao Servidor
package integracao; import javafx.io.http.HttpRequest; import java.io.InputStream; import persistencia.AgendaDao; import javafx.data.pull.PullParser; import javafx.data.pull.Event; import entidade.Contato; import javafx.async.RunnableFuture; def urlServidor = "http://localhost:8084/servicoAgendaFX/contatos"; public class RequisicaoServidor extends RunnableFuture { public-init var agendaDao: AgendaDao; override public function run(): Void { HttpRequest { location: urlServidor onInput: function (inputStream: InputStream) { var contato: Contato; try { var parser: PullParser = PullParser { input: inputStream documentType: PullParser.XML onEvent: function (e: Event) { if (e.type == PullParser.START_ELEMENT and e.qname.name == "contato") { contato = Contato { id: Long.parseLong(e.getAttributeValue("id")) nome: e.getAttributeValue("nome") ddd: Integer.parseInt(e.getAttributeValue("ddd")) telefone: Integer.parseInt(e.getAttributeValue("telefone")) } agendaDao.salvarOuAtualizaContato(contato); } } } parser.parse(); } finally { inputStream.close(); } } }.start();
71
} }
72
8. ANEXOS
Palavras reservadas
abstract into this after inverse throw and last trigger as lazy true assert mod try at new tween attribute not typeof before null var bind on where bound or while break override with catch package this class postinit throw continue private trigger def protected true delete public-init try else public tween exclusive public-read typeof extends replace var false return where finally reverse while first sizeof with for static this from step throw
