• Download do projeto de exemplo compilado para Palm OS - 4 Kb
• Download do projeto de exemplo compilado para Windows Mobile - 46 Kb
• Download código-fonte do projeto de exemplo - 57 Kb

Introdução

Existem diversas tecnologias para desenvolvimento de softwares para dispositivos móveis, algumas mais apropriadas para PDAs, outras para celulares, algumas que podem ser utilizadas em ambos, enfim, opção é o que não falta. Neste artigo, vamos falar sobre uma tecnologia que vem crescendo, e muito, nos últimos anos e que está se consolidando no mercado como uma das melhores opções para o desenvolvimento para dispositivos móveis, principalmente PDAs, o SuperWaba.

O SuperWaba

O SuperWaba é um projeto brasileiro, criado por Guilherme Campos Hazan, e é baseado no projeto Waba, criado por Rick Wild. O "SW", como é chamado pelos usuários da tecnologia, possui uma sintaxe muito semelhante ao Java (praticamente igual, a única diferença é não possuir a implementação para o comando synchronized), mas não pode ser chamada de Java por questões legais. Por ter esta incrível semelhança, você pode desenvolver aplicativos em qualquer IDE de desenvolvimento para a linguagem Java, como Eclipse e NetBeans, ou ainda com o bom e velho Bloco de Notas, por exemplo.

Podemos executar um mesmo aplicativo desenvolvido com o SuperWaba em PDAs sistema operacional com Palm OS 3.0 (ou superior), Windows CE (HPC 2000, Pocket PC, HPC 211 ou superior), em celulares com Symbian OS 7 (ou superior), em computadores desktop com Windows (Windows 98 ou superior) ou Linux e também em browsers que suportam a tecnologia de Applets (a maioria).

Para desenvolver utilizando o SWSDK (SuperWaba Software Development Kit), você terá que esquecer a API do JavaSE e utilizar a API desenvolvida pela equipe do SuperWaba. Esta API é pequena comparada à API do JavaSE, mas possui muitos recursos e possibilita a construção de aplicações bastante completas, sem necessitar de outras ferramentas para o auxilio.

O SuperWaba possui duas versões, a Community e a Professional, ambas open-source. A primeira está sob a licença GPL, que obriga que o código-fonte de sua aplicação seja disponibilizado publicamente, e a outra está sob a licença LGPL, que permite a construção de aplicativos sem a necessidade de disponibilizar o código-fonte. Existem diferenças na API disponibilizada nas duas versões, enquanto a versão Community possui o "básico" para se desenvolver e versão Professional trás uma série de classes já testadas que auxiliarão, e muito, no desenvolvimento do seu aplicativo. Assim, se você quiser apenas testar a ferramenta e/ou desenvolver pequenos projetos para uso pessoal, a versão Community é perfeita para você. Já para desenvolver aplicativos comerciais o ideal é adquirir a licença Professional.

Ferramentas Necessárias

Para desenvolver softwares utilizando a plataforma SuperWaba, você deverá ter instalado os seguintes componentes em seu computador:

• Java SE Development Kit (JDK) 6u1 ou superior;
• Ambiente de Desenvolvimento Integrado (IDE) Eclipse 3.2.2 ou superior;
• SuperWaba 5.73 Community ou superior.

Caso não possua estes componentes instalados, utilize os links acima para efetuar o download.

Importante: Para efetuar o download do SuperWaba 5.73 Community, você deverá se cadastrar no site para ter acesso ao link de downloads. Ao término do download, basta executar o instalador e seguir os passos. Por padrão, o SuperWaba é instalado na pasta C:\SuperWabaSDK, e esta é a estrutura de diretórios criada pelo instalador:

Configuração do Ambiente de Trabalho (workspace)

Para este, e outros artigos, vamos trabalhar com a IDE Eclipse, e embora exista um plugin chamado SuperWaba-IDE que auxilia no processo de configuração do ambiente, neste artigo mostraremos como configurar tudo passo-a-passo, para que você saiba o que está sendo feito para construir seu ambiente de trabalho. A instalação da IDE não é abordada neste artigo.

Inicie o Eclipse, para darmos início à configuração da IDE. Acesse o menu File > New > Project.

Na lista de seleção de tipos de projetos, escolha o item Java Project, e aperte o botão Next.

Em seguida, dê um nome ao seu Projeto e clique novamente no botão Next. Neste exemplo, o nome do projeto é OlaMundoSW.

Na guia Libraries, clique no botão Add External JARs para incluir a API do SuperWaba no seu projeto. Procure os seguintes arquivos:

• C:/SuperWabaSDK/lib/SuperWaba.jar;
• C:/SuperWabaSDK/lib/SuperWabaTools.jar.

O próximo passo é anexar o código-fonte e também o javadoc (documentação) da API do SuperWaba, para que possa servir de consulta rápida para nossos projetos. Vamos expandir o item "SuperWaba.jar", clicando no sinal "+" que está ao lado esquerdo da linha "SuperWaba.jar". Em seguida selecione Source attachment, clique em Edit e selecione o diretório C:/SuperWabaSDK/src/java.

Em Javadoc location, clique em Edit e selecione o diretório file:/C:/SuperWabaSDK/docs/html/, e clique em Finish.

Criação do Exemplo "Olá Mundo SW"

Vamos agora, criar um diretório para "armazenar" nossos códigos. Clique com o botão direito sobre o projeto, vá em New > Source Folder e dê um nome para o diretório. Neste exemplo, o nome deste diretório é src.

Após a configuração do ambiente, vamos criar um pequeno exemplo para que possamos verificar se nossa configuração esta correta e, posteriormente, executar o aplicativo diretamente do Eclipse e gerar os arquivos para a instalação do mesmo no PDA.

Clique com o botão direito sobre o diretório que conterá os fontes e vá em New > Class.

Embora o foco do artigo não seja explicar como funciona a estrutura de um aplicativo SuperWaba, vale lembrar que uma aplicação desenvolvida com o SuperWaba deve ter uma, e somente uma, classe que extenda a classe MainWindow, que pertence ao namespace waba.ui. Esta será a interface entre a VM (Máquina Virtual) e o seu programa SuperWaba. Portanto, para continuarmos a construção do nosso exemplo, vamos criar uma classe, por exemplo, com o nome OlaMundoSW que irá extender a classe waba.ui.MainWindow. Após informar os valores dos campos Name e Superclass, clique em Finish.

Após a criação da classe OlaMundoSW, vamos criar o construtor da classe, especializar o método onStart e também o método onEvent. O método onStart será executado após a máquina virtual "instanciar" a classe OlaMundoSW e estará encarregado de adicionar os controles na tela. Já o método onEvent, é responsável pela manipulação dos eventos que correrão no aplicativo. Em nosso exemplo, ele será responsável por "capturar" o clique no botão e fechar o aplicativo.

O código abaixo, mostra a construção completa da classe OlaMundoSW

import waba.ui.Button;
import waba.ui.ControlEvent;
import waba.ui.Event;
import waba.ui.Label;
import waba.ui.MainWindow;
    
public class OlaMundoSW extends MainWindow {

    private Label  lblOla   = null;
    private Button btnClose = null;
    
    
    public OlaMundoSW()
    {
        // Executa o construtor da classe MainWindow (super classe)
        super();
    }
    
    public void onStart() 
    {
        // Executa o método onStart da classe base (super classe)
        super.onStart();
        
        // Cria um objeto do tipo "Label" para exibir um texto na tela
        lblOla   = new Label ("Olá Mundo, sou um novo aplicativo SW!");
        
        // Cria um objeto do tipo "Button", para exibir o botão "Fechar"
        btnClose = new Button("Fechar");

        // Posiciona o Label com a mensagem no centro da tela,
        // tanto na horizontal quanto na vertical
        add(lblOla, CENTER, CENTER);

        // Posiciona o Label com a mensagem no centro da tela,
        // tanto na horizontal, e no final da tela na vertical
        add(btnClose, CENTER, BOTTOM);    
    }
    
    public void onEvent(Event event) 
    {
        // Executa o método onEvent da classe base (super classe)
        super.onEvent(event);
                
        // Um botão foi clicado?
        if (event.type == ControlEvent.PRESSED)
        {
            // É o botão btnClose?
            if (event.target == btnClose)
            {
                // Finaliza a aplicação
                exit(0);
            }
        }
    }
}

Feita a implementação do exemplo, vamos criar uma configuração para que possamos executá-lo diretamente do Eclipse, no Windows, em forma de Applet. Vá em Run > Run.... Clique com o botão direito em cima de Java Application e depois em New.

Primeiro, vamos dar um nome para nossa configuração, neste exemplo, chamo de "OlaMundoSW - Windows". Na guia Main definiremos o projeto (já estará preenchido por padrão) como "OlaMundoSW", o nome da Main Class como waba.applet.Applet e vamos habilitar o checkbox cujo o label tem o seguinte conteúdo "Include libraries when searching for a main class", para que o Eclipse consiga localizar a classe que definimos como a classe principal.

Na guia Arguments, precisamos definir os argumentos necessários para a execução do projeto no Windows. Os argumentos utilizados podem ser:

• /w - Largura (Width) em pixels;
• /h - Altura (Heigth) em pixels;
• /scale - Escala (de 1 a 4);
• /bpp - Bits por pixel (2, 4, 8 ou 16);
• /t - Título na janela que será aberta.
• ClassName - Nome da classe que extende a MainWindow.

O último argumento corresponde ao nome da classe que extende a MainWindow, ou seja, OlaMundoSW. Neste exemplo, utilizaremos os seguintes argumentos, onde defino que o Applet será executado com tamanho de 240 x 320, escala 1, 16 bits por pixel, e com o título "OlaMundoSW_Windows":

/w 240 /h 320 /scale 1 /bpp 16 /t OlaMundoSW_Windows OlaMundoSW

Após definir os argumentos, clique em Apply e depois em Run.

Neste momento, o projeto é compilado e executado a partir do Windows, em forma de Applet. É dessa forma que os projetos são executados durante o processo de desenvolvimento. Quando o projeto chega ao fim, e já se tem uma versão estável, geramos versões específicas para a(s) plataforma(s) onde desejamos executar nosso aplicativo. Em outras palavras, durante o processo de desenvolvimento não precisamos utilizar emuladores ou PDAs. Podemos efetuar todos os testes no Windows, executando a aplicação em forma de Applet, até chegarmos à versão que será distribuída.

Geração dos Executáveis para cada Plataforma

Agora já temos nosso ambiente de trabalho configurado. O próximo passo é gerar os arquivos que serão instalados nos PDAs, por exemplo, gerar o arquivo .PRC para Palm OS e o .CAB para Windows Mobile. O processo de geração dos executáveis para cada plataforma, requer a criação de um arquivo XML que descreve como o projeto deve ser compilado e para quais plataformas. A descrição detalhada deste arquivo XML não é descrita neste artigo, no entanto foi disponibilizado um exemplo deste arquivo XML, e explico os principais itens que devem ser modificados em outros projetos. Efetue o download do arquivo XML de exemplo, e grave em uma pasta de seu computador que seja diferente da pasta do projeto. Em seguida, clique com o botão direito sobre o projeto e vá em Import.... Expanda o item General clicando no sinal "+" à esquerda de "General", clique em File System e depois em Next. Selecione o diretório onde foi gravado o arquivo XML acima citado e importe-o para dentro de seu projeto selecionando-o dentro da estrutura do diretório e clicando em Finish.

Abra o arquivo importado para que possamos analisar o que devemos mudar neste e em novos projetos. Na tag project altere o atributo name para o nome do seu projeto, e o atributo basedir para o diretório anterior ao diretório do seu workspace. Logo abaixo, nas tags property vamos definir a classe que extende a classe MainWindow e também o diretório do nosso workspace. Se você utiliza o produto LiteBase, que é um SGBD (Banco de Dados) fornecido pela equipe do SuperWaba, apenas retire o comentário que existe no arquivo.

Para executar a sequência de comandos definidas no arquivo XML clique com o botão direito sobre o mesmo (no Package Explorer), vá em Run As Ant Build (o atalho é Alt+Shift+X,Q).

Neste exemplo, serão gerados os arquivos executáveis a serem instalados em PDAs Palm OS e Windows Mobile. Este arquivos serão gerados na pasta "[caminho do workspace]/[nome do projeto]/dist". Na figura abaixo, pode-se notar realçados na cor verde, os arquivos utilizados para a instalação no Windows Mobile (.CAB) e em cor azul os arquivos utilizados para a instalação no Palm OS (.PRC e .PDB). Se fosse necessário gerar executáveis também para a plataforma Symbian OS, bastaria configurar o XML e recompilar o projeto, lembrando que as APIs para trabalhar com a plataforma Symbian estão disponíveis apenas na versão Professional do SuperWaba.

Instalando a Máquina Virtual do SuperWaba no Simulador Palm OS

Os arquivos utilizados para a instalação da Máquina Virtual SW (VM) variam de dispositivo para dispositivo, neste artigo vamos instalar a VM do SuperWaba no Palm OS Garnet 5.4 Simulator (PSIM), para simular a execução do exemplo na plataforma Palm OS 5.0, e também instalaremos a VM PDA Pocket PC, para demonstrar a execução da aplicação na plataforma Pocket PC / Windows CE.

Acesse a pasta C:\SuperWabaSDK\lib\vm para visualizar os diretórios de cada uma das plataformas e também o diretório xplat que contém os arquivos comuns a todas elas.

Execute o Palm OS Simulator, e dentro da pasta C:\SuperWabaSDK\lib\vm, acesse o diretório xplat e, literalmente, arraste o arquivo SuperWaba.pdb para cima do simulador. Em seguida, novamente dentro da pasta C:\SuperWabaSDK\lib\vm acesse o diretório palm\68k\PalmOS5_or_4_with_16bits_screen e arraste os arquivos SuperWaba.prc e SWNatives.prc para o simulador.

Após a instalação, é recomendado reiniciar o simulador, por isso, clique com o botão direito sobre o ele, vá em Reset e clique em Soft, para que que o simulador inicie as configurações do novo software.

Após reinicializar o simulador, na categoria Unfiled você verá o ícone de um aplicativo com o logotipo do SuperWaba, execute este aplicativo e veja informações sobre a máquina virtual que você acabou de instalar.

Instalando o programa exemplo no Simulador Palm OS

Após instalar a máquina virtual do SW, acesse o diretório dist, que está dentro do diretório do projeto, e arraste os arquivos com extensão .PDB e .PRC para cima do simulador (Em nosso exemplo, os arquivos são OlaMundoSW.prc e OlaMundoSW.pdb). Novamente, reinicialize o simulador, para completar a instalação do nosso exemplo. Finalizada instalação, assim como aconteceu com a VM, será mostrado um ícone correspondente ao aplicativo do nosso projeto. Execute esta aplicação e veja o resultado.

Instalando a Máquina Virtual do SuperWaba no em um PDA Pocket PC

Já sabemos como testar o nosso aplicativo diretamente no Eclipse e também no Palm OS Simulator, agora vamos ver como é feita a instalação em um PDA com Pocket PC / Windows CE. Neste exemplo, mostro a instalação do SuperWaba em um PDA iPAQ Pocket PC h2210.

Para instalar o SuperWaba, já com o PDA conectado ao seu PC, apenas acesse a pasta SuperWabaSDK\bin\installers\vm\ce e execute o arquivo _CEinstall-RunMe.bat.

Instalando o programa exemplo no PDA Pocket PC

Para transferir o exemplo para o PDA vá à pasta dist do nosso projeto e execute o arquivo OlaMundoSW_Install.bat e a instalação será feita automaticamente.

Lembre-se que você deve ter o Microsoft ActiveSync instalado no seu PC!

Conclusão

Este artigo teve como objetivo ensinar ao desenvolvedor a configurar um ambiente de desenvolvimento SuperWaba e mostrar como fazer o deploy (distribuição / instalação) da aplicação desenvolvida.

Nos próximos artigos, vamos desenvolver um pequeno aplicativo com duas "pontas", uma em SuperWaba (PDA) e outra utilizando Java (retaguarda).

Abraço e até a próxima.

Histórico

• 01/07/2007 - Primeira versão deste artigo.

Sobre o Autor

Veja o todos os artigos publicados por José Volmei Dal Prá Junior no PDAExpert.

Artigos Relacionados

• Palm OS e Windows CE: Desenvolvimento de Aplicações
• Após encerramento site AppForge é redirecionado para Oracle
• AppForge encerra operações
• Programação do Pocket PC: com eMbedded Visual Basic
• Aprenda a Programar Handheld e Pocket PC