Explicação JME install

Prévia do material em texto

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 HotSpot VM KVM Vard VM
Java Language
Jini Connection Technology
Java 2
Enterprise
Edition
Java 2
Standard
Edition
Smart Card
ProfileJava 2 Micro Edition
Personal
Profile Wireless
Profile
 
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; 
 
Configurations
Perfil 1 Perfil 2
 
 
 
 
 
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 
MID
Aplicações
MIDP
Aplicações OEM
Específicas
Sistema Nativo
CLDC
Aplicações
Nativas
Classes Específias
OEM
MIDP
 
 
 
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
DestruidoPausado
destroyApp()
st
ar
tA
pp
()
pa
us
eA
pp
()
destroyApp()
 
 
 
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; 
 
 
Display Displayable
High-Level API
Low-Level API
1
*1 1
*
1
Alert List TextBox Form Item
ChoiceGroup DateField Gauge ImageItem StringItem TextField
Screen Canvas
MIDlet
 
 
 
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 inseridosmais 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