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
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 Edition Java 2 Standard Edition Personal Profile Wireless Profile Java 2 Micro Edition Smart Card 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
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
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 MIDP Aplicações OEM Específicas Aplicações 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
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 startapp() pauseapp() destroyapp() Pausado destroyapp() 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
Composição do MIDP javax.microedition.lcdui: Display; Screen: Alert, TextBox, List, Form; Item: TextField, StringItem, ImageItem, ChoiceGroup, DateField; Canvas; Graphics; Command; CommandListener; MIDlet 1 1 Display 1 * Displayable Low-Level API High-Level API Screen Canvas Alert List TextBox Form Item 1 * ChoiceGroup DateField Gauge ImageItem StringItem TextField Grupo de Usuários Java http://www.guj.com.br Página 6
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
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
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
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
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
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
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
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
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
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
Clique em Next. Grupo de Usuários Java http://www.guj.com.br Página 17
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
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
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
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
Clique em Next. Clique em Next. Grupo de Usuários Java http://www.guj.com.br Página 22
Esta parte fia a seu critério. Clique em Next. Grupo de Usuários Java http://www.guj.com.br Página 23
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
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
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
Escolha o nome do projeto (utilizaremos HelloWorld) e clique em Next. Grupo de Usuários Java http://www.guj.com.br Página 27
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
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
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
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
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
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
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
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
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
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
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
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