Você está na página 1de 39

Java Manaus

http://www.javamanaus.com.br

Um pouco mais que “Hello World”


Leonardo Gall
Este artigo tem como objetivo preparar não só um ambiente de desenvolvimento J2ME de uma
maneira simples e prática, mostrando e explicando passo a passo tudo o que foi feito, mas
também fazer um esquema de geração de pacotes com o Ant.

Introdução

Neste Tutorial não trataremos apenas da Tecnologia J2ME MIDP 2.0, mas mostraremos algumas das
inúmeras possibilidades desta linguagem bem como ferramentas utilizadas para facilitar as nossas vidas,
CVS como repositório de dados e Ant para gerar os builds e nas próximas versões JavaDoc para gerar
documentação da aplicação, Persistência, Multimídia e Internet dentre outros recursos.

A quem se destina este tutorial?

Este tutorial é destinado a pessoas que já programam em Java e estejam interessadas em desenvolver
aplicativos para dispositivos móveis (J2ME), apresenta um passo a passo de como configurar um
ambiente de desenvolvimento e algumas ferramentas que facilitam a vida do desenvolvedor.

Por quê começar com “Hello World”?

Todo mundo se pergunta porque fazer uma aplicação que mostre apenas “Hello World”? O motivo de
fazer a aplicação bem simples na primeira vez tem um fator psicológico, o objetivo é fazer com que a
aplicação rode na primeira tentativa, isso faz com que a pessoa fique mais confiante em relação à
linguagem, o que não seria o caso de uma primeira aplicação onde a pessoa já começa com dificuldades
para implementar como um “Hello World Turbinado” que não funciona, neste caso a pessoa já ficaria com
a impressão de ter uma certa dificuldade, pois já começou com problemas.

Grupo de Usuários Java – http://www.guj.com.br – Página 1


Java Manaus
http://www.javamanaus.com.br

O que é e como Funciona o J2ME

O J2ME (Java 2 Micro Edition) é uma plataforma que implementa a linguagem JAVA e é utilizado em
dispositivos móveis, como celulares, smartphones, Palm Tops, Pocket PCs, algumas TV´s de nova
geração, dentre outros.

Plataformas

Java 2
Enterprise Java 2
Edition Standard Personal
Edition Wireless
Profile
Profile
Smart Card
Java 2 Micro Edition Profile

Jini Connection Technology

Java Language

Java HotSpot VM KVM Vard VM

J2EE (Java 2 Enterprise Edition) Plataforma para Servidores.


J2SE (Java 2 Standard Edition) Plataforma para Desktops.
J2ME (Java 2 Micro Edition) Plataforma para Micro Dispositivos.

Noções básicas de J2ME

O J2ME é uma versão reduzida do J2SE, foram feitas remoções e algumas modificações em partes
fundamentais do J2SE, isso foi feito para que houvesse a possibilidade de rodar a linguagem em um
dispositivo com capacidade limitada, com pouca memória e baixo processamento. O J2ME é dividido em
Configurations, Profiles e API´s.

Grupo de Usuários Java – http://www.guj.com.br – Página 2


Java Manaus
http://www.javamanaus.com.br

Configurations

Responsável por definir um denominador comum que é suportada por uma determinada categoria de
dispositivos, atualmente existem dois tipos de configuração, CDC (Connected Device Configuration) e
CLDC (Connected Limited Device Configuration)

CLDC – configuração mais leve


Desenvolvido para dispositivos com capacidade limitada
PDA´s (gama baixa), Telefones Celulares, pagers, ...
Minimo de 128 k para executar a VM;
32 k para alocação de memória;
Interface mais restrita;

CDC – configuração mais pesada


Desenvolvido para dispositivos com maior capacidade
PDA´s (gama alta), Set-top boxes, gateways, TV´s, ...
Minimo de 512 k para executar a VM;
256 k para alocacao de memória;

Profiles

Responsável pela API (Application Programming Interface) que é definida para uma determinada
“família” de dispositivos. Os Profiles são implementados sobre uma determinada configuração
(Configuration).

MIDP 1.0
128 kB de memória não volátil;
32 kB para heap;
8 kB para persistência de dados;
Tela de 96x54 pixels;
Entrada de dados;
Conexões de rede (intermitentes);
Segurança – conceito de sandbox das applets;

MIDP 2.0
Segurança: baseado em permissões do J2SE;
Novas API´s para aprimorar o desenvolvimento:
● Game API;
● Media API;
● Secure Connection API;

Perfil 1 Perfil 2

Configurations

Grupo de Usuários Java – http://www.guj.com.br – Página 3


Java Manaus
http://www.javamanaus.com.br

Maquina Virtual (KVM)

A KVM (Kilo Virtual Machine) é uma implementação da VM (Virtual Machine) otimizada para ser
utilizado em dispositivos limitados e foi desenvolvida para ser facilmente portável.

Arquitetura MIDP

Aplicações Aplicações OEM Aplicações


MIDP Específicas Nativas

Classes Específias
OEM

MIDP

CLDC

Sistema Nativo

MID

MIDlet

As “MIDlets” são aplicações desenvolvidas sobre a plataforma J2ME.

Introdução ao Ciclo de Vida de uma MIDlet

Cada dispositivo possui um AMS (Aplication Manager System) que é responsável por controlar os
aplicativos que serão instalados e também administrará como serão armazenados e como será o seu
comportamento durante a execução. Uma coisa que deve ser ressaltada é a importância do arquivo JAD
que vem acompanhado com o arquivo JAR, no JAD estão todas as informações que o JAR precisa para
executar a MIDlet.

Grupo de Usuários Java – http://www.guj.com.br – Página 4


Java Manaus
http://www.javamanaus.com.br

Estados de uma MIDlet

Start – Onde é feita a Aquisição de recursos inicializando a execução (startApp);


Pause – Liberação de recursos em um modo de espera, ou seja, pausado utilizado ao atender telefone,
receber SMS dentre outra aplicação (pauseApp);
Destroy – Liberação de todos os recursos (destroyApp);

Início

Ativo
)
p(

de
Ap

()

s
rt

tr
pp
a

oy
st

eA

Ap
us

p(
pa

destroyApp()
Pausado Destruido

Application Manager (AMS)

A AMS é um software pré-instalado em dispositivos MIDP que funciona como um ambiente


operacional, e é responsável pela chamada dos métodos, startApp(), pauseApp() e destroyApp(),
conforme o ciclo de vida visto acima. Veremos mais detalhadamente quando estivermos fazendo a nossa
primeira aplicação.

Grupo de Usuários Java – http://www.guj.com.br – Página 5


Java Manaus
http://www.javamanaus.com.br

Composição do MIDP

javax.microedition.lcdui:
– Display;
– Screen: Alert, TextBox, List, Form;
– Item: TextField, StringItem, ImageItem, ChoiceGroup, DateField;
– Canvas;
– Graphics;
– Command;
– CommandListener;

1 1 1 *

MIDlet Display Displayable

Low-Level API

High-Level API Screen Canvas

1 *

Alert List TextBox Form Item

ChoiceGroup DateField Gauge ImageItem StringItem TextField

Grupo de Usuários Java – http://www.guj.com.br – Página 6


Java Manaus
http://www.javamanaus.com.br

AMBIENTE DE DESENVOLVIMENTO

Ferramentas utilizadas

Antes de começar a por a mão na massa, você terá que instalar e configurar os softwares necessários
para o desenvolvimento. Para este tutorial foram utilizados, JDK, WTK, Eclipse, EclipseME (plugin do
Eclipse), SMTK e um emulador (Siemens). Vale ressaltar que os PrintScreens são do W2K (Windows
2000), isso não impede de fazê-lo em um ambiente linux, porém neste tutorial abordaremos apenas sob
o Windows.

Download, Instalação e Configuração

Abaixo segue uma seqüência de como baixar, instalar e configurar o ambiente de desenvolvimento:

JDK

O JDK (Java Developer´s Kit) é composto pelo compilador (javac), máquina virtual, bibliotecas de
desenvolvimento, e um programa utilizado para a composição de documentos em formato html
(javadoc), dentre outros.

Download do JDK:
http://java.sun.com/JDK/1.4.2/download.html

Instalação do JDK:

Leia os termos da licença para dar início a instalação.

Grupo de Usuários Java – http://www.guj.com.br – Página 7


Java Manaus
http://www.javamanaus.com.br

Neste ponto selecione os itens que serão instalados, normalmente é instalado como sugerido
na imagem.

Escolha todos os Browsers que você possuir.

Grupo de Usuários Java – http://www.guj.com.br – Página 8


Java Manaus
http://www.javamanaus.com.br

Finalização.

Após a instalação o seu OS deve ser reiniciado.

Grupo de Usuários Java – http://www.guj.com.br – Página 9


Java Manaus
http://www.javamanaus.com.br

Configuração do Sistema:

Agora serão configuradas as variáveis de ambiente, clicando com o botão direito em ”Meu
Computador”, “Propriedades”, aba “Avançado” e “Enviroment Variables” conforme imagem
abaixo.

Em “Variáveis do sistema” clique em “Nova...”, caso esta variável já exista clique em


“Editar...”.
Agora deverá ser criada a variável JAVA_HOME
Nome da variável: JAVA_HOME
Valor da variável: Caminho do seu SDK, isso vai depender de onde foi instalado o SDK, no
exemplo está em:
C:\j2sdk1.4.2_03

Grupo de Usuários Java – http://www.guj.com.br – Página 10


Java Manaus
http://www.javamanaus.com.br

Agora o “HOME” deve ser preenchido.


O mesmo princípio deve ser adotado para a variável “PATH”, mas caso não exista crie uma
nova variável editando a existente e adicionado:
;%JAVA_HOME%\bin;%JAVA_HOME%\lib

A imagem abaixo mostra como ficarão a variáveis após a figuração.

Grupo de Usuários Java – http://www.guj.com.br – Página 11


Java Manaus
http://www.javamanaus.com.br

WTK

O WTK (Wireless Toolkit) é responsável pelo gerenciamento do projeto, ou seja, compila,


pré-verifica e empacota (JAR) as MIDlets;

Download do WTK:

http://java.sun.com/products/j2mewtoolkit/download-2_1.html

Instalação do WTK:

Os termos de licença devem ser lidos para dar início a instalação.

Grupo de Usuários Java – http://www.guj.com.br – Página 12


Java Manaus
http://www.javamanaus.com.br

Especificação de onde se encontra o SDK, caso não seja selecionado automaticamente clique
em “Browse...” para localizá-lo.

Especificação de onde se encontra o WTK, caso não seja selecionado automaticamente


clique em “Browse...” para localizá-lo.

Grupo de Usuários Java – http://www.guj.com.br – Página 13


Java Manaus
http://www.javamanaus.com.br

Configuração do WTK:

Não há.

Eclipse

O Eclipse é uma IDE de desenvolvimento, com ele é possível ter um maior controle durante
o desenvolvimento, pois indica onde existem erros, facilita os imports, dentre outros recursos.

Download do Eclipse:

http://eclipse.org/downloads

Instalação do Eclipse:

O Eclipse não possui um Setup, para instalá-lo basta descompactar o arquivo que foi
baixado em qualquer diretório.

Configuração:

Não há.

EclipseME

O EclipseME é um plugin do Eclipse para desenvolvimento de MIDlets.

Download do EclipseME:

http://eclipseme.sourceforge.net

Instalação do EclipseME:

O arquivo baixado deverá ser salvo de preferência na pasta plugins que se encontra dentro
da pasta Eclipse.

Grupo de Usuários Java – http://www.guj.com.br – Página 14


Java Manaus
http://www.javamanaus.com.br

Configuração do EclipseME:

Para a configuração abra o Eclipse e siga os passos:


Ir no menu "Help | Software Update | Find and Install...".

Escolha a segunda opção "Search for new features to install" clicar em "Next".

Clique em: "Add Archived Site..." e informe onde está o plugin (arquivo zip) que foi baixado
e em seguida clique em "Ok".

Grupo de Usuários Java – http://www.guj.com.br – Página 15


Java Manaus
http://www.javamanaus.com.br

Agora aparecerão os itens que compõem o arquivo que foi baixado, marque os itens a serem
utilizados e em seguida clique em “Next”.

Grupo de Usuários Java – http://www.guj.com.br – Página 16


Java Manaus
http://www.javamanaus.com.br

Clique em “Next”.

Grupo de Usuários Java – http://www.guj.com.br – Página 17


Java Manaus
http://www.javamanaus.com.br

Agora os termos da licença devem ser lidos, para continuar a instalação deve ser marcada a
opção “I acept the terms in the license agreements” e em seguida clique em “Next”.

Grupo de Usuários Java – http://www.guj.com.br – Página 18


Java Manaus
http://www.javamanaus.com.br

Todos os passos para a instalação foram seguidos, agora basta clique em “Finish”.

Grupo de Usuários Java – http://www.guj.com.br – Página 19


Java Manaus
http://www.javamanaus.com.br

Agora deverá ser feita uma configuração no Eclipse:


Dentro do Eclipse adicione o MIDP, através do Menu "Window | Preferences" (neste local está a janela
com as devidas configurações).

Expandindo a opção J2ME clicando no (+) faça a inclusão do WTK, escolhendo “Platform
Components” e clicando com o botão direito em "Wireless Toolkits" e em seguida em “Add
Wirelles Toolkit” selecione o diretório "c:\WTK21", que deve ser o diretório onde foi instalado o
WTK.

SMTK

O SMTK (Siemens Mobile Tool Kit) é um Kit de desenvolvimento fornecido pela Siemens, para baixá-lo
você terá que se cadastrar no site, na finalização do cadastro você receberá um email.

Cadastro e Download do SMTK:

http://www.siemens.com/developer
Links:Emulator Packs for 65 Generation
SMTK Info & Quick Start (Read this first!), neste local estão o SMTK e o Emulador
referente a alguns celulares, portanto o que deve ser baixado é o SMTK e no mínimo um
Emulador.

Grupo de Usuários Java – http://www.guj.com.br – Página 20


Java Manaus
http://www.javamanaus.com.br

Instalação do SMTK:

Agora os termos da licença devem ser lidos para continuar a instalação e em seguida clique
em “Next”.

Informe onde se encontra o seu SDK e clique em Next.

Grupo de Usuários Java – http://www.guj.com.br – Página 21


Java Manaus
http://www.javamanaus.com.br

Clique em Next.

Clique em Next.

Grupo de Usuários Java – http://www.guj.com.br – Página 22


Java Manaus
http://www.javamanaus.com.br

Esta parte fia a seu critério.

Clique em Next.

Grupo de Usuários Java – http://www.guj.com.br – Página 23


Java Manaus
http://www.javamanaus.com.br

Emulador

O Emulador é um software que junto ao SMTK emula um dispositivo, neste caso um celular Siemens,
com ele é possível rodar as aplicações antes de embarcá-lo no celular.

Download do Emulador:
No passo acima já foi baixado o SMTK junto com o Emulador.

Instalação do Emulador:

Clique em Next para dar início a instalação.

Grupo de Usuários Java – http://www.guj.com.br – Página 24


Java Manaus
http://www.javamanaus.com.br

Agora os termos da licença devem ser lidos para continuar a instalação e em seguida clique
em “Next”.

Observação
Embarcar significa que a aplicação desenvolvida (jad e jar) será copiada para dentro
do dispositivo.

Grupo de Usuários Java – http://www.guj.com.br – Página 25


Java Manaus
http://www.javamanaus.com.br

Primeira MIDlet

A partir de agora será mostrada uma aplicação simples, o famoso “Hello World”. Neste capítulo será
utilizado o compilador via prompt e em um capítulo posterior utilizaremos técnicas (Ant) que facilitarão o
processo de codificar, compilar, pré-verificar e empacotar, o fato de ainda não utilizar dessas ferramentas
tem um objetivo, que é mostrar como fazer todo este processo de compilação e pré-verificação via
prompt e com isso facilitar o entendimento da utilização do “Ant”.

Para começar o desenvolvimento da aplicação “Hello World” abra o Eclipse, após isso vá ao menu
“File”, “New”, “Project...” aparecerá uma janela conforme a imagem abaixo, expanda o item “J2ME”
clicando em (+), após isto clique em “J2ME MIDlet Suite" e “Next”.

Grupo de Usuários Java – http://www.guj.com.br – Página 26


Java Manaus
http://www.javamanaus.com.br

Escolha o nome do projeto (utilizaremos HelloWorld) e clique em “Next”.

Grupo de Usuários Java – http://www.guj.com.br – Página 27


Java Manaus
http://www.javamanaus.com.br

Escolha a plataforma “J2ME Wireless Toolkit 2.1 MIDP Platform” e clique em “Next”.

Grupo de Usuários Java – http://www.guj.com.br – Página 28


Java Manaus
http://www.javamanaus.com.br

Neste momento será montada a estrutura de diretórios, para isto siga os passo abaixo:
Clicando em “Add Folder...” insira os seguintes diretórios “bin”, “class” e “src”, a estrutura ficará como
na imagem acima.

Grupo de Usuários Java – http://www.guj.com.br – Página 29


Java Manaus
http://www.javamanaus.com.br

Após ter criado o projeto deveremos criar o arquivo “HelloWorld.java” para isso vá ao menu “Window”,
“Show View” e “Other”, em “Java” escolha “Package Explorer”, observando que a estrutura de diretórios
está como foi definida, ou seja, tem os diretórios “bin”, “class” e “src”.

Grupo de Usuários Java – http://www.guj.com.br – Página 30


Java Manaus
http://www.javamanaus.com.br

No “src” deve-se clicar com o botão direito e escolha “New”, “File” e no campo “File Name” digite
HelloWorld.java e clique em “Finish”.

Grupo de Usuários Java – http://www.guj.com.br – Página 31


Java Manaus
http://www.javamanaus.com.br

Digite o seguinte código no arquivo que acabou de ser criado “HelloWorld.java”:

import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;

public class HelloWorld extends MIDlet implements CommandListener {


private Command exitCommand;
private TextBox tbox;

public HelloWorld() {
exitCommand = new Command("Exit", Command.EXIT, 1);
tbox = new TextBox("Hello world MIDlet", "Hello World!", 25, 0);
tbox.addCommand(exitCommand);
tbox.setCommandListener(this);
}

protected void startApp() {


Display.getDisplay(this).setCurrent(tbox);
}

protected void pauseApp() {}


protected void destroyApp(boolean bool) {}

public void commandAction(Command cmd, Displayable disp) {


if (cmd == exitCommand) {
destroyApp(false);
notifyDestroyed();
}
}
}

Dica
Removendo os import´s o Eclipse acusará erros devido à falta dos mesmos, para
resolver este problema existem algumas opções:

1º Clicar sob Command e pressione “Ctrl+1” observando que aparecerá o seu


respectivo import, o mesmo ocorre para TextBox e assim segue para o restante.
2º Pressionando “Ctrl+Shift+O” e todos os import´s serão adicionados.

Grupo de Usuários Java – http://www.guj.com.br – Página 32


Java Manaus
http://www.javamanaus.com.br

Compilando

De posse do arquivo “HelloWorld.Java", vá ao prompt e posicione no diretório onde o mesmo se


encontra (Ex: C:\MIDlets\src) e sabendo em que diretório está a API que irá ser utilizada, digite a linha
abaixo verificando os seus devidos paths ([path_da_api] e [path_do_diretório_das_classes]):

javac -bootclasspath [path_da_api_do_emulador]\api.jar -d


[path_do_diretório_das_classes] HelloWorld.java

Pré-Verificando

De posse do arquivo “HelloWorld.java” será feita a pré-verificação para que ele esteja dentro
dos parâmetros do MIDP, para isso posicione o prompt no diretório onde se encontra o arquivo
compilado e digitando a linha abaixo:

preverify -classpath [path_da_api_do_emulador]\api.jar;. -d . HelloWorld

Criando o Pacote .JAR

Após ter seguido os passos de Compilação e Pré-Verificação será criado um pacote (arquivo
HelloWorld.jar), para isso posicione o prompt no diretório onde se encontra o arquivo
compilado e digite a linha abaixo:

Jar cf HelloWorld.jar HelloWorld.class

Criando o Arquivo .JAD

De posse do arquivo .JAR será criado o arquivo .JAD que é onde ficam informações
referentes ao .JAR, informações como tamanho do arquivo JAR, nome da MIDlet, ícone da
aplicação, dentre outros, para a criação do mesmo, para isso crie um arquivo texto com
extensão .JAD no mesmo diretório onde se encontra o .JAR, com o seguinte conteúdo:

MIDlet-1: HelloWorld, HelloWorld.png, HelloMIDlet


MIDlet-Jar-Size: 112 (aqui será colocado o tamanho do arquivo .JAR)
MIDlet-Jar-URL: HelloWorld.jar
MIDlet-Name: HelloWorld
MIDlet-Vendor: Sun Microsystems
MIDlet-Version: 1.0

Executando a MIDlet

Após ter criado o arquivo JAD com as especificações do JAR o mesmo será executado no
emulador, para isso deve-se digitar o comando abaixo:

emulator -Xdescriptor:[path_do_JAD/JAR]:\HelloWorld.jad

Grupo de Usuários Java – http://www.guj.com.br – Página 33


Java Manaus
http://www.javamanaus.com.br

Ant

O Ant é uma ferramenta desenvolvida em Java pela Apache que tem como objetivo executar
comandos em forma de um script, é algo parecido com um arquivo .bat do Windows e ao Make do Linux
que executam tarefas rotineiras, sendo que o Ant utiliza de scripts escritos em XML (Extensible Markup
Language) para tal.

Neste tutorial não será necessário fazer download do Ant, pois o Eclipse que já vem com o mesmo,
desta forma o Ant será executado de dentro do próprio Eclipse.

Neste capítulo serão mostrados conceitos básicos do Ant e também como facilitar o processo de
compilar, pré-verificar e executar uma aplicação, todos estes passos serão executados pelo Ant.

Primeiro Exemplo de Ant

Dentro do Eclipse no projeto criado, deve-se criar um arquivo chamado build.xml, de preferência na
raiz do projeto, dentro deste arquivo deve ser digitado o seguinte código:

<?xml version="1.0" encoding="ISO-8859-1"?>


<project name="Hello World" basedir="." default="executar">
<target name="executar">
<echo message="Testando o Ant"/>
</target>
</project>

Grupo de Usuários Java – http://www.guj.com.br – Página 34


Java Manaus
http://www.javamanaus.com.br

De posse do arquivo agora o Ant deve ser executado, vá em Window | Show View | Ant e em seguida
arraste o arquivo build.xml, que está em Window | Show View | Navigator ou Package Explorer, para
dentro do Ant.

Observe que aparecerá “Hello World [executar]”, no Ant clicando no (+) para explodir a perspectiva do
mesmo aparecerá “Executar [default]”.

Agora dê um duplo clique no “executar”, por enquanto só imprimirá:

[echo] Testando o Ant.

Entendendo o que foi feito

No Ant existe um target default (neste caso <target name="executar">) que sempre existirá, isso não
impede de termos vários target´s e também não impede de termos um target vazio, que não faça nada.
No exemplo também temos <echo message="Testando o Ant"/> que é responsável por imprimir uma
mensagem, que no caso é “Testando o Ant”.

Grupo de Usuários Java – http://www.guj.com.br – Página 35


Java Manaus
http://www.javamanaus.com.br

Incrementando o Ant

No exemplo anterior foi criado um xml simples que apenas imprime um texto, agora serão inseridos
mais itens, para isso antes do target “executar” digite a seguinte linha:

<property name="teste" value="Valor do teste"></property>

E dentro do target altere a linha:

<echo message="Testando o Target"/>

para

<echo message="${teste}"/>

Após executar o valor de ${teste} será impresso, neste caso "Testando o Target", ou seja, o property
funciona como uma variável.

Além dos target´s o Ant possui também property, path e tasks, os tasks são tarefas
executadas pelos target´s,

Properties

Como foi visto acima o property funciona com o mesmo conceito de variável, no caso deste tutorial
utilizaremos muito o property para guardarmos os paths das libs, classes, etc.

Declarando um property:
<property name="teste" value="Valor do teste"/>

Utilizando um property:
<echo message="${teste}"/>

Path

O path é o caminho utilizado para informar ao Ant onde estão os arquivos que serão utilizados, para
não ter que informar arquivo por arquivo. O path é utilizado em diversos momentos, como em cópia de
arquivos para um determinado lugar (path), criação de diretórios, exclusão de diretórios,
empacotamento, etc.

Exemplo de utilização do path:


<property name="path" value="c:\testando"></property>

Grupo de Usuários Java – http://www.guj.com.br – Página 36


Java Manaus
http://www.javamanaus.com.br

Task

O task é utilizado para executar tarefas ou comandos, como o java, javac, copy, delete, etc. O task é
muito utilizado para executar as tarefas de compilar, pré-verificar, empacotar e executar. Abaixo seguem
dóis exemplos simples, um pouco mais à frente será mostrado o processo de compilação, pré-verificação,
geração de pacotes e chamada do Emulador.

Exemplo de como criar um diretório:


<property name="path" value="c:\testando"></property>
<target name="cria_dir" description="Criando um Diretório">
<mkdir dir="${path}"/>
</target>

Exemplo de como copiar o conteúdo de um path para outro:


<property name="destino.path" value="c:\destino"></property>
<property name="origem.path" value="c:\origem"></property>
<target name="copia_arquivos" description="Copiando Arquivos">
<copy todir="${destino.path}" overwrite="yes" failonerror="no">
<fileset dir="${origem.path}"/>
</copy>
</target>

Compilando, Pré-verificando, Gerando Pacotes e chamando a Aplicação no Emulador pelo


Ant

Utilizando os princípios citados acima será dado início aos passos que realmente interessam, que é o
de facilitar a vida em relação à compilação, pré-verificação, geração de pacote como estes passos foram
seguidos no prompt do DOS, agora será mostrado como fazer tudo isso com o Ant.

Grupo de Usuários Java – http://www.guj.com.br – Página 37


Java Manaus
http://www.javamanaus.com.br

Para um melhor entendimento do que está sendo feito no xml, serão declarados alguns path´s, são
eles:

Path´s

class.path
<!-- este path é referente às bibliotecas do WTK que são necessárias para a compilação -->
<property name="class.path"
value="C:\WTK21\lib\midpapi20.jar;C:\WTK21\lib\cldcapi11.jar;C:\WTK21\lib\mmapi.jar;C:\WTK21\lib\wma
.jar;C:\WTK21\lib\j2me-ws.jar"/>

preverify.path
<!-- neste path encontra-se o preverify.exe -->
<property name="preverify.path" value="C:\WTK21\bin"/>

project.dir
<!-- neste path encontra-se o diretório do projeto -->
<property name="project.dir" value="C:\local_do_projeto"/>

project.name
<!-- neste path encontra-se o nome do projeto -->
<property name="project.name" value="HelloWorld"/>

Comando para compilação


<javac bootclasspath="${class.path}" destdir="${project.dir}\class"
srcdir="${project.dir}\src"></javac>

Comando para Pré-Verificação


<exec dir="${preverify.path}" executable="preverify.exe" failonerror="yes">
<arg line="-classpath ${class.path} -cldc -d ${project.dir}\class ${project.dir}\class" />
</exec>

Gerando o JAD
Como visto anteriormente um aquivo .JAD possui a seguinte estrutura:

MIDlet-1: HelloWorld, HelloWorld.png, HelloMIDlet


MIDlet-Jar-Size: 112
MIDlet-Jar-URL: HelloWorld.jar
MIDlet-Name: HelloWorld
MIDlet-Vendor: Sun Microsystems
MIDlet-Version: 1.0

Para que não haja preocupação em gerar um .JAD na “mão” será mostrado como gerá-lo dentro do
próprio Ant, para isso será usado o echo:

<!-- este comando gera um arquivo texto, neste caso “HelloWorld.jad”, com o conteúdo do arquivo .JAD
-- >
<echo file="${project.dir}/bin/${project.name}.jad" append="true">
MIDlet-1: ${project.name}, ${project.name}.png, ${project.name}
MIDlet-Jar-Size: 0
MIDlet-Jar-URL: ${project.name}.jar
MIDlet-Name: ${project.name}
MIDlet-Vendor: Sun Microsystems
MIDlet-Version: 1.0 level="warning" append="on"
</echo>

Grupo de Usuários Java – http://www.guj.com.br – Página 38


Java Manaus
http://www.javamanaus.com.br

Observação
Enquanto o projeto estiver rodando apenas no Emulador e não no device (aparelho
celular/palm tops etc...) deixe o “MIDlet-Jar-size: 0” pois o Emulador não encontrará
problemas para executar a MIDlet, porém quando este .JAD for embarcado no device e
aconselhável que o arquivo .JAD seja alterado, colocando o tamanho real do .JAR.

Empacotando

Neste passo será gerado o arquivo .JAR do MIDlet HelloWorld contendo todas as classes necessárias,
neste caso só uma, para executar o projeto.

<jar destfile="${project.dir}\bin\${project.name}.jar">
<fileset dir="${project.dir}\class"/>
<fileset dir="${project.dir}\bin"/>
</jar>

Executando o emulador

<target name="openProject">
<exec dir="C:" executable="\siemens\SMTK\emulators\S65\bin\emulator.exe"
failonerror="yes">
<arg line='-load_apps ${project.dir}\bin\${project.name}.jar'/>
</exec>
</target>

Observação
Seu xml deve seguir a seguinte estrutura:

<?xml version="1.0" encoding="ISO-8859-1"?>


<project name="Hello World" basedir="." default="executar">
<!-- Neste trecho entram as declarações de “variáveis” (path´s) -->
<target name="compilar">
<!-- Neste trecho entram comandos -->
</target>
<target name="pre-verificar">
<!-- Neste trecho entram comandos -->
</target>
<target name="empacotar">
<!-- Neste trecho entram comandos -->
</target>
<target name="executar">
<!-- Neste trecho entram comandos -->
</target>
</project>

Sempre deverá haver um target com o mesmo nome que o default, no caso é
“executar”.
A quantidade de target´s fica a critério de cada um, os comandos podem ser divididos
em cada target ou pode-se colocar tudo em um mesmo target.

Conclusão

Conclua algo, o melhor é sempre apontar pontos positivos e negativos que o assunto abordado possui.

Leonardo Gall (leonardo_esposti_gall@yahoo.com.br) trabalha no desenvolvimento de aplicativos para dispositivos


móveis.

Grupo de Usuários Java – http://www.guj.com.br – Página 39