Automatizando o processo de construção de um projeto J2ME – Parte 02

por Paulo Silveira

A Aplicação de teste

Para este artigo usaremos um MIDlet bem simples apenas para demonstrar as capacidades do Antenna. O código do nosso HelloWebMobile se encontra na Listagem 1.

package br.com.portalwebmobile.edicao1;

 

import javax.microedition.lcdui.Canvas;

import javax.microedition.lcdui.Display;

import javax.microedition.lcdui.Graphics;

import javax.microedition.midlet.MIDlet;

import javax.microedition.midlet.MIDletStateChangeException;

 

public class HelloWebMobile extends MIDlet {

         protected void startApp() throws MIDletStateChangeException {

                   Display display = Display.getDisplay(this);

                   display.setCurrent(new WebMobileCanvas());

         }

 

         protected void pauseApp() {

         }

 

         protected void destroyApp(boolean arg0) throws MIDletStateChangeException {

         }

}

 

class WebMobileCanvas extends Canvas {

 

         protected void paint(Graphics g) {

                   g.setColor(0, 0, 0);

                   g.fillRect(0, 0, this.getWidth(), this.getHeight());

                   g.setColor(255, 255, 255);

                   g.drawString("Web Mobile #1", 0, 0, Graphics.TOP | Graphics.LEFT);

         }

}

Listagem 1. Hello WebMobile.

 

Um código tão pequeno pode dar bastante trabalho até chegar no seu dispositvo. Agora vamos ver como o Antenna pode nos ajudar.

O build.xml

Vamos inicialmente definir algumas variáveis (ver Listagem 2).

 

<project name="HelloWebMobile" default="package" basedir=".">

 

         <property name="src" value="src"/>

         <property name="build" value="temp/bin"/>

         <property name="midlet.name" value="br.com.portalwebmobile.edicao1.HelloWebMobile"/>

         <property name="jar.name" value="HelloWebMobile"/>

Listagem 2.

 

Perceba que o diretório de build é diferente do Eclipse para não entrar em conflito com as classes geradas pelo Eclipse. Precisamos também definir as tasks que vamos utilizar, além de configurar onde o Antenna poderá achar os executáveis do Wireless Toolkit, já que ele se baseia nesses programas (ver Listagem 3).

 

         <taskdef resource="antenna.properties"/>

         <property name="wtk.home" value="c:/WTK21"/>

Listagem 3.

 

O arquivo antenna.properties não precisa estar em lugar algum, já que ele se encontra no jar do Antenna, e será encontrado pois o colocamos no classpath.

Vamos também definir uma task básica de limpeza do diretório de build (ver Listagem 4).

 

         <target name="clean">

                   <delete dir="${build}"/>

                   <mkdir dir="${build}"/>

         </target>

Listagem 4.

Compilando

A task wtkbuild é uma extensão da task javac, que dá mais opções para você poder trabalhar diretamente com as possibilidades do WTK.

 

         <target name="compile" depends="clean">

                   <wtkbuild srcdir="${src}"

destdir="${build}"/>

         </target>

 

Ao rodar o target compile, o resultado deve ser algo como o apresentado na Listagem 5.

 

Buildfile: D:\javaprograms\j2meworkspace\hello-webmobile\build.xml

clean:

   [delete] Deleting directory D:\javaprograms\j2meworkspace\hello-webmobile\temp\bin

    [mkdir] Created dir: D:\javaprograms\j2meworkspace\hello-webmobile\temp\bin

compile:

 [wtkbuild] **************************************************************

 [wtkbuild] * Antenna 0.9.13 initialized for project "HelloWebMobile"    *

 [wtkbuild] * Using Sun Wireless Toolkit 2.1 (CLDC-1.0; MIDP-1.0)        *

 [wtkbuild] **************************************************************

 [wtkbuild] Compiling 1 source file to D:\javaprograms\j2meworkspace\hello-webmobile\8b21d6ad.tmp\tmpclasses

 [wtkbuild] Preverifying D:\javaprograms\j2meworkspace\hello-webmobile\8b21d6ad.tmp\tmpclasses

BUILD SUCCESSFUL

Total time: 3 seconds

Listagem 5.

 

Assim como na task javac, você pode definir o classpath e outros atributos.

Criando o JAD

O descritor da sua aplicação J2ME pode ser facilmente criado através da task wtkjad:

 

         <target name="jad">

                   <wtkjad jadfile="${build}/${jar.name}.jad"

                            jarfile="${build}/${jar.name}.jar"

                            name="${midlet.name}"

                            vendor="PortalWebMobile.com.br"

                            version="0.9">

                            <midlet name="${jar.name}" class="${midlet.name}"/>

                   </wtkjad>

         </target>

Empacotando e pré-verificando

Podemos criar o jar da sua aplicação usando a task wtkpackage. Ela é uma extensão do jar:

 

         <target name="package" depends="compile, jad">

                   <wtkpackage jarfile="${build}/${jar.name}.jar"

                            jadfile="${build}/${midlet.name}.jad" preverify="true">

                            <fileset dir="${build}" includes="**/*" excludes="**/*.jad">

                            </fileset>

                   </wtkpackage>

         </target>

 

wtkpackage precisa que o .jar já exista, e ele vai atualizar os dados do .jad, tal como o tamanho do jar.

A pré-verificação ocorre aqui, mas poderia ter ocorrido durante o wtkbuild com a mesma opção (preverify).

Rodando o emulador

Vamos criar agora um target para rodar o emulador.

 

         <target name="run" depends="package">

<wtkrun jadfile="${build}/${jar.name}.jad"

device="DefaultColorPhone" wait="true"/>

         </target>

 

A opção wait indica se o Ant deve esperar ou não pelo término do emulador. Device indica qual tipo de aparelho deve ser usado, tais como DefaultGreyPhone e MinimumPhone. Rodando a aplicação o emulador deverá abrir, e selecionando a aplicação você terá a figura 5.

 

wm-19-06-2008pic01.jpg 

Figura 5.

Obfuscador

O obfuscador não serve apenas para dificultar o trabalho de engenharia reversa, mas é também essencial para diminuir, em muito, o tamanho das classes geradas. O Antenna detecta automaticamente a presença de alguns obfuscadores (ProGuard e Retroguard). Basta você colocar um deles no classpath do Ant (Figura 4), e quando for gerar o jar, coloque a opção de obfuscação para true:

 

         <target name="package" depends="compile, jad">

                   <wtkpackage jarfile="${jar.name}.jar"

jadfile="${build}/${jar.name}.jad" preverify="true" obfuscate="true">

                            <fileset dir="${build}" includes="**/*" excludes="**/*.jad">

                            </fileset>

                   </wtkpackage>

         </target>

Conclusões

O Antenna facilita muito o processo de build de aplicações J2ME e pode ser facilmente integrado a qualquer IDE que tenha suporte ao Apache Ant, ou mesmo para usar via linha de comando. Todas as tasks aqui apresentadas ainda possuem uma série de outras opções, consulte a página do Antenna para uma listagem completa.

As próximas versões do Antenna terão suporte a outros emuladores, como da Nokia, Siemens, etc. Espera-se também por tasks que auxiliem no processo de signing de MIDlets.

 

Paulo Silveira (paulo.silveira@caelum.com.br) é formado em Ciência da Computação pela Universidade de São Paulo, onde realiza seu mestrado. Trabalhou no Brasil e na Alemanha em empresas e consultorias, e é um dos fundadores do GUJ (http://www.guj.com.br). Atualmente é consultor e instrutor pela Caelum (http://www.caelum.com.br). Paulo Silveira é um dos colaboradores do código do Antenna.

 

Instalação do Antenna?

Como você viu no artigo, não há instalação do Antenna, basta você colocar o jar no path de runtime do Ant da sua IDE. Apesar disso o Antenna necessita que você tenha configurado a variavel PATH do seu sistema operacional corretamente, pois ele realiza chamadas ao “jar” quando vai empacotar sua aplicação. Se o jar não estiver no caminho do seu sistema, o Antenna gera mensagens de erro muito estranhas, dizendo que a pré-verificação falhou, quando o erro esta em outro lugar.

 

Outros recursos do Antenna

Palm - Se você quiser fazer o deploy da sua aplicação para a palm, o Antenna ainda conta com a task  WtkMakePrc para que você crie o seu PRC.

 

WTK 2.2 - O Wireless Toolkit 2.2 da Sun está em beta, mas o Antenna 0.9.13 já possui suporte a ele. O WTK2.2 traz suporte a novas APIs, como a Mobile 3D Graphics (JSR 184).

 

Pré-processador – Programando em J2ME, muitas vezes você encontra situações onde quer que o jar resultante seja um pouco diferente para cada dispositivo. Um conjunto de abstrações (como factories e utilização de interfaces) podem resolver o problema, mas gasta um preciso espaço do JAR resultante. Outra solução é usar um pré-processamento à maneira antiga, com #defines e #ifdefs, e o Antenna vem com um sistema simples para isso. Eu particularmente não gosto deste tipo de saída.

 

Verbose – Muitas das tasks do Antenna possuem a opção verbose, que você pode deixar em true para que o Antenna diga exatamente o que está fazendo e chamando.

 

Plugin para o Maven - se a sua ferramenta de build é o Apache Maven, você pode utilizar um plugin que é o wrapper das tasks do Antenna, veja o quadro de links.

 

Milestones do Eclipse 3.1

O Eclipse 3.1 ainda está em seus primeiros meses de desenvolvimento, mas tem ganho muitos adeptos devido aos recursos do java 5.0. Cuidado com alguns milestones (como o M1) que não trabalham corretamente com user libraries, fazendo com que a substituição do rt.jar pelos jars do cldc e midp não funcionem corretamente (o Eclipse reclama que java.lang.Object não existe).

 

Links

Apache Ant

http://ant.apache.org/

 

Antenna

http://antenna.sf.net/

 

Eclipse

http://www.eclipse.org/

 

Netbeans

http://www.netbeans.org/

 

Wireless ToolKit

http://java.sun.com/products/j2mewtoolkit/

 

Proguard

http://proguard.sf.net/

 

MIDP

http://java.sun.com/products/midp/

 

CLDC

http://java.sun.com/products/cldc/

 

Maven Antenna plugin

http://wlab.ethz.ch/plugins/maven-antenna/