Um pouco mais que Hello World

(1)

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.

(2)

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

Standard

Java 2

Edition

Smart Card

Profile

Java 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

(3)

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

(4)

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

(5)

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

Destruido

Pausado

destroyApp()

st

ar

tA

pp

()

pa

us

eA

pp

()

des

troyAp

p()

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.

(6)

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

(7)

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:

(8)

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

na imagem.

(9)

Finalização.

(10)

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:

(11)

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

(12)

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:

(13)

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.

(14)

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.

(15)

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".

(16)

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”.

(17)

(18)

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”.

(19)

(20)

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.

(21)

Instalação do SMTK:

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

em “Next”.

(22)

(23)

Esta parte fia a seu critério.

(24)

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:

(25)

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.

(26)

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”

(27)

(28)

(29)

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.

(30)

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”.

(31)

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”.

(32)

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.

(33)

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:

(34)

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"?>

(35)

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

(36)

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:

E dentro do target altere a linha:

para

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:

Utilizando um property:

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:

(37)

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:

</target>

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

</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.

(38)

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

Path´s

class.path

<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

 <property name="preverify.path" value="C:\WTK21\bin"/>

project.dir

 <property name="project.dir" value="C:\local_do_projeto"/>

project.name

 <property name="project.name" value="HelloWorld"/>

Comando para compilação

Comando para Pré-Verificação

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:

(39)

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.

Executando o emulador

<exec dir="C:" executable="\siemens\SMTK\emulators\S65\bin\emulator.exe"

failonerror="yes">

</target>

Observação

Seu xml deve seguir a seguinte estrutura:

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

<target name="compilar">

</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