Instalando e configurando o plugin Eclipse ME

Caros amigos. Fiquei bastante tempo de "férias", mas agora estou retomando as dicas práticas para construção de conhecimento em Java ME.

Neste post demonstrarei como integrar o emulador WTK com a IDE Eclipse, tudo isso usando um plugin para Eclipse chamado eclipseme. Esse conjunto de ferramentas permitirão começar o desenvolvimento de forma produtiva.

Pré-requisitos

• Versão do Eclipse instalado (sugiro versão 3.2 ou superior)
• Wireless Tool Kit instalado (WTK, versão 2.5 ou superior)

Instalando o plugin

A maneira mais simples para instalar o plugin no eclipse é utilizar o próprio update manager do eclipse para baixar e instalar o plugin desejado. Será dessa maneira que faremos aqui. Com o eclipse em execução siga o passo a passo abaixo (resumo):

• Clique em "Help" / "Software updates..." / "Find and Install"
• A tela de "Install/Update" irá aparecer com duas opções, seleciona a opção "Search for new features to install" e clique no botão "next"
• Na tela de "Install", pressione no botão "New remote site";
• Agora aparece uma pequena tela onde você deverá informar o nome do software e a URL para download, assim colocaremos respectivamente: "Eclipse ME"; "http://www.eclipseme.org/updates", e clique "OK"
• Agora é só prosseguir clicando no botão "Finish".
• Após baixar o arquivo o eclipse pedirá para você confirmar a instalação, oinde deverá clicar no botão "Install All". Após instalação é sugerido reiniciar o Eclipse para ativar o plugin.
  

A seguir as principais screenshots para te orientar nos passos:

Figura 1: acessando o update manager do eclipse

Figura 2: acessando a opção do update manager para baixar novas features

Figura 3: colocando o endereço do novo repositório (nova feature)

Figura 4: tela de seleção de features a serem procurados para download

Figura 5: feature do plugin eclipseme encontrado, basta confirmar o seu download

Figura 6: confirmação de instalação do plugin (último passo)

Configurando o Eclipse para se comunicar com o WTK

Após instalar o plugin eclipseme você deve acessar a tela de preferência do eclipse para configurar o plugin. Basicamente é só apontar onde está o diretório de instalação do seu WTK. Então acesse com o Eclipse em execução: Windows / Preferences. Observe que a opção J2ME estará disponível (figura 7). Na tela de preferences, clique em: J2ME/Device Management. Então clique no botão "Import", no qual aparecerá a tela da figura 8.

Figura 7: tela de preferências do eclipse

Figura 8: tela de "import devices"

Figura 9: tela de import após clicar no botão Refresh.

Na tela de import (Figura 8 e 9) devemos apontar para o diretório de instalação do seu WTK e em seguida clicar no botão refresh para atualizar o número de devices disponíveis. Com isso realizado você já poderá criar seus projetos J2ME no eclipse. Façamos um único teste simples.

Fazendo um teste: criando um projeto J2ME no eclipse

Crie um novo projeto no eclipse do tipo J2ME. Clique em New / Project / J2ME / J2ME MIDlet Suite, em seguida preencha um nome para o projeto. (tela da figura 9)

Figura 9: criando no projeto J2me no eclipse

Figura 10: configurando o emulador para seu projeto

A tela da figura 10 aparece após a escolha do nome do projeto. Caso não apareça opções nesta tela, então é preciso configurar o plugin Eclipse ME instalado no seu eclipse conforme instruções neste blog. Se aparecer, basta agora selecionar e associar o WTK para seu projeto. Os próximos passos você precisaria criar a classe MIDlet e para rodar sua aplicação (clicando no RUN do eclipse e configurando uma execução para Wireless Tool Kit Emulator).

Neste post vimos como baixar o plugin Eclipse ME e como podemos instalar na IDE Eclipse, assim poderemos criar nossas classes (codificação) e executar nossas aplicações (testes) nesta IDE.

No próximo post continuaremos com as dicas - espero não demorar tanto para postar outro post. :) Obrigado pela visita e deixe seu recado se quiser.

Introdução a programação para celulares com suporte a Java ME – parte 4

Este post faz parte de uma série de artigos técnicos sobre o desenvolvimento de software para celulares. No primeiro artigo, abordamos os conceitos básicos da tecnologia com ênfase na arquitetura de Java ME. No segundo artigo, analisamos um exemplo de código Java que ilustra o ciclo de vida da aplicação. No terceiro artigo, verificamos como são empacotadas as aplicações – conhecidas como MIDlet Suíte. Neste quarto artigo, veremos como desenvolver um exemplo de aplicação, passando pelas fases clássicas: codificar, compilar e testar os programas; tudo isso usando um ambiente de emulação do celular.

Introdução

Os desenvolvedores de aplicações Java ME podem construir e testar seus programas sem a necessidade de um telefone celular real, através dos programas emuladores. No entanto, essas ferramentas não reproduzem fielmente o comportamento dos diversos modelos de celulares existentes no mercado, por isso, acredito que deveriam denominar-se de simuladores e não emuladores. É preciso então estar ciente desse fato.

De fato, existem softwares especialmente desenvolvidos para simular o comportamento dos celulares reais. Os principais fornecedores desses programas são os próprios fabricantes de celulares, tais como Nokia e Motorola. A Sun Microsystems também oferece recursos para os desenvolvedores através do seu software WTK (Wireless Tool Kit). Nesta primeira experiência usaremos a ferramenta da SUN – WTK, por ser uma ferramenta bastante didática e de propósito geral. Se suas intenções for desenvolver software para um aparelho específico, então seria interessante utilizar um simulador do respectivo aparelho, se existir.

Ambiente de Desenvolvimento WTK

Conforme citado, usaremos o WTK 2.5 (versão mais estável e atual na data deste post). A ferramenta do Toolkit inclui ambientes de emulação, ferramentas para otimização e desempenho, documentação e exemplos que os desenvolvedores necessitam para construir de forma rápida aplicações simples ou avançadas. O WTK facilita o entendimento do ciclo de vida do desenvolvimento: codificar; compilar (pré-verificar), e rodar (testar). Veremos também alguns exemplos usando linha de comando para demonstrar esse ciclo.

O download do WTK bem como os seus pré-requisitos:

http://java.sun.com/products/sjwtoolkit/download-2_5.html

dica: após instalar, coloque no PATH do sistema o diretório de instalação: (ex. C:\WTK25\bin), e crie uma variável CLASSPATH e coloque (C:\WTK25\lib). Isso permitirá trabalhar através da linha de comando.

Testando sua instalação

Iremos testar se tudo foi instalado corretamente:

1. vá para o prompt de comando (Command Prompt);
2. para testar a instalação do CLDC digite o comando “preverify”, você deverá ver os comandos conforme a figura 1 abaixo;
3. agora digite o comando “emulator -version” para testar as configurações disponíveis do WTK.

Figura 1: testando a ferramenta pré-verificador e emulator

Os emuladores atuais suportam uma especificação chamada UEI (Unified Emulator Interface), que é um padrão para interação entre ambientes IDE (Integrated Development Environments) e os dispositivos emuladores. Sendo assim, fica fácil testar todos os programas simplesmente através da ferramenta “emulator”. Experimente digitar no prompt de comando “emulator -help”. São através desses comandos que o Eclipse IDE por exemplo, através de plugins, se comunica com os emuladores do WTK.

Escrevendo um exemplo e testando através do emulator WTK

A maneira mais fácil de criar e testar um programa é utilizando a ferramenta “ktoolbar”. Abra esse programa digitando no prompt de comando “ktoolbar” ou clique no atalho do menu “Iniciar”. Então clique no botão “New Project”, dois campos são necessários, o nome do projeto (coloque PrimeiroProjeto), e o nome do MIDlet (coloque PrimeiroProgramaMIDlet). Agora vá para o diretório C:\WTK25\apps\PrimeiroProjeto\src e crie o arquivo com o código abaixo:

import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Form;
import javax.microedition.midlet.*;

/**
* Esta classe desenha uma mensagem na tela e implementa um botão para sair.
*
* @author Douglas D. Del Frari
*/
public class PrimeiroProgramaMIDlet extends MIDlet implements CommandListener {

// representa o display da aplicacao
private Display display;

// representa o comando de sair
private Command cmdQuit;

// representa uma interface de formulario
private Form form;

/** Construtor */
public PrimeiroProgramaMIDlet() {
display = Display.getDisplay(this);

cmdQuit = new Command("Sair",Command.EXIT,1);
form = new Form("Titulo do Programa");

// adicionando um texto no formulario e tambem o botao "sair"
form.append("Testando meu primeiro exemplo...");
form.addCommand(cmdQuit);

// registrando o tratamento dos eventos do formulario (botao sair) nesta classe
form.setCommandListener(this);
}

/* (non-Javadoc)
* @see javax.microedition.midlet.MIDlet#destroyApp(boolean)
*/
protected void destroyApp(boolean b) throws MIDletStateChangeException {
// chamado quando nossa aplicação será finalizada
this.notifyDestroyed();
}

/* (non-Javadoc)
* @see javax.microedition.midlet.MIDlet#pauseApp()
*/
protected void pauseApp() {
// somente será chamado quando houver uma interrupção do SO
}

/* (non-Javadoc)
* @see javax.microedition.midlet.MIDlet#startApp()
*/
protected void startApp() throws MIDletStateChangeException {
// Ponto Inicial de nossa aplicação
display.setCurrent(form);
}

/* (non-Javadoc)
* @see javax.microedition.lcdui.CommandListener#commandAction(javax.microedition.lcdui.Command, javax.microedition.lcdui.Displayable)
*/
public void commandAction(Command c, Displayable d) {
if (c == cmdQuit) {
try {
destroyApp(true);
} catch (MIDletStateChangeException e) {
e.printStackTrace();
}
}

}
}

Próximos passos: Compilando o programa e rodando o MIDlet

1. Clique no menu Project;
2. Clique na opção Build
3. Clique na opção Run
4. Com o emulador rodando clique no botão direito abaixo da opção “Launch”
5. Clique no botão esquerdo “Sair”

Figura 2: Compilando o primeiro projeto com WTK

Figura 3: rodando o emulador padrão

Analisando o código fonte
Toda aplicação precisa herdar de MIDlet para poder implementar o ciclo de vida, representado através dos métodos:

• destroyApp() apenas chamou o comando para finalizar a aplicação;
• pauseApp() nada foi feito ainda;
• startApp() direcionou o componente do formulário (form) para ser exibido;

Foram definidos atributos para representar um comando (cmdQuit), um formulário para colocar as coisas gráficas (form). Note que precisamos SEMPRE definir ou capturar o display do aparelho, isso foi feito através da classe Display.

No construtor desta classe os objetos foram instanciados. Detalhe é que neste caso precisamos capturar os eventos que o usuário poderá fazer, por isso implementamos a interface CommandListener, que nos obriga implementar o método CommandAction, que receberá os eventos dos componentes registrados. O comando foi registrado no próprio MIDlet, pois foi nesta classe que desejamos neste exemplo tratar os eventos. Normalmente, escolhemos outra classe para tratar eventos.

No próximo artigo veremos alguns exemplos usando a API de MIDP, visando explorar os seus recursos gráficos de alto nível que são "bem fáceis" de utilizar, até lá!

Introdução a programação para celulares com suporte a Java ME – parte 3

Este post faz parte de uma série de artigos técnicos sobre o desenvolvimento de software para celulares. No primeiro artigo, abordamos os conceitos básicos da tecnologia Java ME, enfatizando os fundamentos de sua arquitetura. No segundo artigo, analisamos um exemplo de código Java que ilustra o ciclo de vida da aplicação. Neste terceiro post, estudaremos o tipo de empacotamento de nossas aplicações, que serão representadas por uma suite MIDlets (MIDlet Suite).


Introdução
Após muita reflexão sobre o conteúdo deste post, achei relevante abordar como nossas aplicações são empacotadas, pois esse conhecimento facilitará e contextualizará o leitor para a distribuição das aplicações a terceiros, bem como permitirá testar em telefones celulares reais. Assim, quando codificarmos alguns exemplos e desejarmos testá-los nos ambientes apropriados, já saberemos o essencial para gerar o software – conhecido como gerar um pacote da distribuição.

A Suite de MIDlet
Um MIDlet é uma aplicação Java projetada para ser executada sobre um dispositivo móvel. Mais especificamente, um MIDlet tem no seu core classes do Java de CLDC e MIDP. Uma suite de MIDlet consiste de uma ou mais MIDlets empacotados através de um arquivo JAR (Java ARchive). Bem, em outras palavras, quase todos as aplicações vem com um instalador ou executável no qual rodamos nosso software, no caso de uma aplicação MIDlet, esse padrão obedece a mesma abordagem que Java SE e suas bibliotecas. Será através desse arquivo que o gerenciador da aplicação (AMS - Application Manager Software, post anterior), irá instalar, executar e remover os MIDlets.

Quando o AMS inicia um MIDlet ele basicamente fará as seguintes verificações:

• acesso ao CLDC e a máquina virtual java;
• acesso as classes definidas de MIDP; geralmente definem as implementações das interfaces do usuário, esquema de persistência, suporte a rede através dos protocolos de comunicação (ex. HTTP), tempos e configurações do usuário com o celular;
• acesso ao arquivo JAR; se a aplicação usa arquivos de imagens, estas deverão estar empacotadas neste aquivo JAR, caso contrário ocorrerão erros.
• acesso as informações do arquivo JAD (Java Application Descriptor); Se uma suite de MIDlet tiver um arquivo JAD, então seu conteúdo deverá estar disponível, podendo descrever mais de um MIDlet no mesmo pacote de aplicação.

Em teoria, podemos compartilhar recursos entre MIDlets diferentes, a memória de armazenamento do celular por exemplo, poderá ser acessada por dois MIDlets completamente diferentes. Essa memória pode ser tratada através do pacote RMS de MIDP2. No entanto, a maioria dos celulares suporta apenas a execução de uma aplicação por vez. Teríamos que fechar a execução do MIDlet corrente, e executar o próximo MIDlet. No futuro, a especificação de MIDP 3 promete resolver essa limitação.

JAR
Uma aplicação irá geralmente consistir em muitos arquivos. Além das tradicionais classes do Java (arquios .class), adicionalmente teremos imagens, sons e dados diversos, conhecidos como recursos (resources ou res). Dentro do JAR teremos obrigatoriamente um arquivo que define todas as propriedades da aplicação, bem como o MIDlet Suite. Esse arquivo segue a regra de Java SE, me refiro ao arquivo MANIFEST (manifest.mf). A figura 1 ilustra as propriedades desse arquivo.

Figura 1: Propriedades do arquivo MANIFEST

As principais propriedades são aquelas que indicarão para o AMS o nome de nossa aplicação, a sua localização do nome da classe MIDlet (pode conter vários pacotes no caminho), a versão do CLDC e MIDP. Na prática, toda vez que desejarmos testar nossa aplicação em algum celular necessitaremos especificar esse arquivo, pois caso contrário, o AMS não encontrará o MIDlet para ser executado. Vejamos um exemplo real de um MANIFEST da aplicação Mobile English Learning que estou mantendo:

Manifest-Version: 1.0
MIDlet-Vendor: Oxe Tche group
MIDlet-Version: 1.0.0
MIDlet-1: English Learning,res/firststeps16.PNG,oxetche.EnglishLearningMIDlet
MicroEdition-Configuration: CLDC-1.1
MIDlet-Name: English Learning
MicroEdition-Profile: MIDP-2.0

Já o arquivo JAD desta aplicação possui as seguintes propriedades:

MIDlet-1: English Learning,res/firststeps16.PNG,oxetche.EnglishLearningMIDlet
MIDlet-Jar-Size: 31462
MIDlet-Jar-URL: projeto-MobileEnglishLearning.jar
MIDlet-Name: English Learning
MIDlet-Vendor: Oxe Tche group
MIDlet-Version: 1.0.0
MicroEdition-Configuration: CLDC-1.1
MicroEdition-Profile: MIDP-2.0

Observe que quando iremos realizar experimentos práticos, utilizaremos ferramentas, plugins e emuladores que farão automaticamente a geração desse JAD/JAR, que servirão como ponto de entrada para realizar o teste de nosso software.

No próximo post, veremos como desenvolver um exemplo de aplicação, passando pelas fases clássicas: codificar, compilar e testar os programas; tudo isso usando um ambiente de emulação do celular.