Iniciando no desenvolvimento com Java MEA teoria por traz do Hello WorldEntenda como funciona e aprenda a desenvolver uma aplicação para celulares e smartphones com Java ME

LAIS ZANFOLIM E RODOLFO CHAVES FERNANDES

Java Micro Edition ou Java ME é uma plataforma que permite o desenvolvimento de aplicações Java para dispositivos com processamento, memória e vídeo limitados, tais como celulares e smartphones. Assim como as outras plataformas Java, a plataforma Java ME foi desenvolvida com o mesmo intuito, a portabilidade, além de possuir diversas APIs (Application Programming Interface) para o desenvolvimento.Neste artigo iremos explorar os conceitos necessários para entender o Java ME. Para isso, é

importante conhecer a arquitetura desta plataforma, bem como o funcionamento de uma aplicação. Durante o artigo será construída uma aplicação exemplo utilizando os principais componentes de interface. A base da plataforma Java ME é constituída por uma máquina virtual, sobre ela estão as configurações e perfis, que serão abordadas no decorrer deste artigo.

ConfiguraçõesNo Java ME, uma configuração define uma especificação padrão para um conjunto de dispositivos

com características individuais de hardware (ex: capacidade de processamento, memória, vídeo e tipo de conexão de rede). Uma configuração possui bibliotecas básicas da linguagem representando a plataforma mínima de desenvolvimento para cada tipo de dispositivo.A Java Community Process (JCP) especifica o Java ME em duas configurações:

• CDC – Connected Device Configuration: Configuração destinada a dispositivos com maior capacidade computacional, como TV Digital, PDAs de alto desempenho e sistemas automotivos;

• CLDC – Connected Limited Device Configuration: Configuração destinada a dispositivos com menor capacidade computacional, geralmente usada em aplicações embarcadas, telefones celulares e smartphones.

Como o nosso objetivo mostrar uma forma de desenvolver aplicações para celulares e smartphones utilizando a plataforma Java ME, vamos explorar apenas a configuração CLDC, voltada para este tipo de dispositivo. A Figura 1 mostra a arquitetura da plataforma Java e destaca a parte do Java ME que será explorada neste artigo.

Figura 1. Arquitetura da Plataforma Java.

Máquinas virtuaisAs máquinas virtuais podem ser da Sun, do próprio fabricante do dispositivo móvel ou de

terceiros. Normalmente, as VMs utilizadas para desenvolver aplicações para celulares e smartphones são especificadas pela Sun, como é o caso da KVM e da CLDC HotSpot Implementation.KVM – Kilo Virtual MachineÉ uma máquina virtual com funções reduzidas, pequena quantidade de memória e um coletor de

lixo (GC ou Garbage Collector) incorporado para otimização da memória.CLDC HotSpot ImplementationÉ uma máquina virtual de alto desempenho e robustez e inclui características que melhoram a

execução da aplicação em comparação com a KVM, bem como uma gestão mais eficiente dos recursos. Uma das mudanças mais importantes nesta máquina virtual foi a introdução da compilação Just-in-time (JIT), que pode ser 50 vezes mais rápida que uma instrução interpretada, como acontecia na KVM.Conforme mencionado, além das máquinas virtuais e das configurações, a arquitetura da

plataforma Java ME também é composta por perfis, que fornecem classes com funcionalidades não suportadas pelas classes fornecidas pelas configurações.

PerfisUm perfil especifica o ciclo de vida da aplicação, os elementos de interface gráfica, a persistência

de dados e as funcionalidades que uma aplicação pode ter, ou seja, define as classes que podem ser utilizadas para a implementação de uma aplicação.Aplicações desenvolvidas em Java ME são construídas sobre configurações e perfis, portanto

podem apenas usar bibliotecas especificadas por estas. Uma configuração pode conter vários perfis, porém um perfil é ligado somente a uma configuração.

Para a configuração CLDC temos o perfil MIDP (Mobile Information Device Profile), que é amplamente utilizado e proporciona ao desenvolvedor um meio de construir uma aplicação para dispositivos limitados e com capacidade de conexão sem fio. Portanto, através do perfil MIDP o desenvolvedor é capaz de construir aplicações para celulares e smartphones.Para otimizar ainda mais o desenvolvimento, temos também os pacotes opcionais, que são

utilizados para enriquecer uma aplicação trazendo funcionalidades não contidas nas configurações, nem nos perfis. Entretanto, os pacotes opcionais podem ou não serem aderidos nas aplicações, já um perfil vem implementado em um aparelho, e para desenvolver uma aplicação para este aparelho é necessário utilizar as classes implementadas por este perfil.

Pacotes opcionaisPacotes opcionais ou APIs são componentes da plataforma Java ME que agregam funcionalidades

à aplicação e oferecem formas de solucionar os problemas com maior abstração. Alguns exemplos de pacotes opcionais são: APIs para suporte a bluetooth (JSR-82); acesso às funcionalidades nativas do aparelho, como agenda, calendário e arquivos (JSR-75); API de segurança e serviços confiáveis (JSR-177), dentre outras.

Entendendo o funcionamento de uma aplicaçãoEsta seção apresenta os tópicos necessários para o entendimento de uma aplicação móvel

utilizando o perfil MIDP. Para mostrar o funcionamento da aplicação será abordado desde o ciclo de vida até os componentes de interface necessários para sua construção.MIDletUm MIDlet é uma aplicação Java destinada a dispositivos móveis desenvolvido com a utilização

do perfil MIDP da configuração CLDC, ou seja, é uma aplicação Java ME construída para ser executada em celulares, smartphones ou em outros dispositivos que implementem o perfil MIDP.Todo dispositivo móvel tem um gerenciador de aplicativos (AM – Application Manager) que

controla os aplicativos a serem instalados, onde serão armazenados e como serão executados. A comunicação do gerenciador com o MIDlet acontece pela classe MIDlet do pacote javax.microedition.midlet.MIDlet. Portanto, o aplicativo deve herdar esta classe, pois ela contém os métodos que inicializam, resumem, interrompem a execução e destroem o MIDlet.Ciclo de vida do MIDletUma aplicação é iniciada quando o AM invoca o método startApp(), colocando a aplicação no

modo ativo. Enquanto estiver executando, ela pode ser pausada pelo AM através do método pauseApp(). Isso pode ocorrer, por exemplo, quando uma chamada for recebida ou o próprio usuário pausar a aplicação. E quando a aplicação é encerrada ela passa para o estado destruído através do método destroyApp(), que limpa todos os recursos utilizados para depois fechar a aplicação. A Listagem 1 mostra os métodos padrões para a criação de um MIDlet. O ciclo de vida do MIDlet é apresentado na Figura 2.Estes três métodos tratam da comunicação que parte do gerenciador de aplicativos para o MIDlet.

Além destes, existem outros três métodos, porém, com a comunicação partindo do MIDlet para o gerenciador, são eles:

• notifyDestroy(): Avisa ao gerenciador que pode encerrar o MIDlet;• NotifyPaused(): Envia o pedido de pausa para o gerenciador caso o MIDlet queira

pausar;• ResumeRequest(): Avisa ao gerenciador que a MIDlet pode tornar-se ativa novamente.

Figura 2. Ciclo de vida do MIDlet.

MIDlet SuiteUm MIDlet Suite consiste de classes Java, recursos (imagens e dados da aplicação), um arquivo de

manifesto que são compactados em um Java Archive (JAR) e um arquivo de descrição, chamado Java Application Descriptor (JAD).No arquivo de manisfesto, cuja extensão é .mf, está a descrição do JAR. O arquivo JAD descreve

os detalhes da aplicação, repetindo muitos dos dados que estão no arquivo de manifesto. Porém, este arquivo está fora do JAR e pode ser acessado sem mesmo instalar o arquivo JAR em um dispositivo.JADO arquivo JAD é usado muitas vezes para preparar o JAR a ser instalado, otimizando a instalação

do aplicativo. Porém, nem todos os aparelhos precisam ler o JAD para realizar a instalação. É importante ressaltar que a configuração deste arquivo oferece alguns recursos adicionais para a instalação do aplicativo de extensão .JAR, como por exemplo, personalização do ícone da aplicação ou o diretório em que o aplicativo deve ser instalado. O arquivo JAD possui a seguinte estrutura:• MIDlet-Name: Nome da Suite MIDlet;• MIDlet-Version: Versão do MIDlet;• MIDlet-Vendor: Desenvolvedor do MIDlet;• MIDlet-Icon: Especifica o ícone da aplicação;• MIDlet-Description: Descrição da aplicação;• MIDlet-Info-URL: Endereço para um arquivo de informações (JAR);• MIDlet-DATA-Size: Tamanho do JAR.

Visto como é o funcionamento de uma aplicação Java ME e que é possível implantar esta aplicação em um dispositivo móvel através dos arquivos de extensão JAR e JAD, vamos conhecer os principais componentes de interface para desenvolver nossa primeira aplicação.InterfaceOs dispositivos móveis que implementam o perfil MIDP possuem diversas restrições quando se

trata de interface, podendo variar em tamanho de tela, número de cores apresentadas, disposições dos botões, entre outros. Estas informações são acessadas pelo MIDlet somente em tempo de execução, sendo assim o MIDP só permite a utilização de objetos visuais simples, impossibilitando a implementação de objetos comuns da versão Java para Desktop.A biblioteca LCDUI é a responsável pelos componentes que formam a interface gráfica das

aplicações MIDP. A Figura 3 mostra as classes desta biblioteca de acordo com sua hierarquia.

Figura 3. Hierarquia de classes.

Para desenvolver interfaces que se encaixem em dispositivos móveis com diferentes características de tela, as aplicações são desenvolvidas com certa abstração. Para acessar as informações de um determinado aparelho existe a classe Display, que captura, em tempo de execução, as informações de tela, disposição dos botões, entre outras características físicas do dispositivo. Cada MIDlet possui sua própria instância desta classe, que pode ser acessada pelo método getDisplay(), geralmente contido no método startApp(), pois o Display só pode ser acessado depois que a aplicação tenha sido iniciada.Displayable é uma classe abstrata que controla o que é mostrado na tela e os comandos

enviados pelos usuários. Eles representam conteúdos de uma tela na qual há interação com o usuário.Portanto, a tela do dispositivo é representada por uma instância da classe Display, que representa

o hardware, e para que seja mostrado algo na tela devemos passar um objeto Displayable para o objeto da classe Display. Cada aplicação possui apenas uma instância da classe Display, desta forma podem existir vários objetos Displayable mas apenas um é mostrado por vez.A classe Displayable dá origem a duas outras classes: Screen e Canvas, ambas utilizadas

para construir interfaces. No exemplo que será desenvolvido, utilizaremos os componentes da classe Screen, pois são objetos gráficos prontos que otimizam o desenvolvimento. Os componentes da classe Screen são listados na Tabela 1. Os componentes que podem ser inseridos em um Form são herdados da classe Item e estão listados na Tabela 2.

Componente DescriçãoAlert Tela de informação ao usuário. Pode conter uma mensagem de erro, de sucesso,

de informação, entre outras.List Lista que permite ao usuário selecionar opções. O List pode ser exclusivo,

múltiplo ou implícito. Exclusivo é quando somente uma opção pode ser selecionada; na forma Múltipla uma ou mais opções podem ser escolhidas, marcando uma caixa de checagem que acompanha os elementos da lista; e implícito é quanto a lista é exibida sem nenhum marcador e somente uma opção pode ser escolhida, gerando um evento quando esta é selecionada.

Textbox Tela que serve para entrada e edição de texto.

Form Formulário no qual podemos inserir textos, imagens e outros componentes para serem exibidos no visor.

Tabela 1. Componentes da classe Screen.

Componente DescriçãoChoiceGroup É uma lista de escolhas que possui os tipos Múltiplo, Exclusivo e Pop Up, sendo

que os dois primeiros funcionam de forma semelhante aos explicados no List e o último é semelhante a um comboBox.

DataField Campo utilizado para exibir e/ou entrar com data e/ou hora.

Gauge É uma representação gráfica de um número inteiro, permitindo ao usuário definir um nível, como volume ou barra de loading.

ImageItem Permite inserir uma imagem.

StringItem É um texto estático que não pode ser editado. Geralmente utilizado para exibição de rótulos.

TextField É um campo para entrada e/ou edição de texto.Tabela 2. Componentes da classe Item.

.Para tornar a interface com o usuário dinâmica é necessário definir ações na aplicação. Um

comando contém informações sobre qual ação realizar. Portanto para uma aplicação realizar alguma ação ela deve conter um ou mais comandos, que podem ser adicionados a um Displayable ou a um Item, através da classe Command. Quando um comando é acionado pelo usuário, é notificado a um CommandListener e a ação do comando é definida.CommandListener é uma interface usada para tratar os eventos, controlando quais e quando os

mesmos foram acionados. O CommandListener vincula um comando a um gatilho, detectando quais comandos foram ativados e definindo gatilhos para eles. Quando um comando é acionado, o commadAction o captura, juntamente com o Displayable atual.Visto todo o funcionamento e os componentes necessários para a criação de uma aplicação, vamos

configurar o ambiente e dar início ao desenvolvimento do nosso exemplo.

Configurando o ambientePara construir a aplicação que será mostrada neste artigo vamos utilizar a IDE NetBeans. Para isso,

basta fazer o download da IDE (atualmente encontra-se na versão 6.8) que trabalhe com a tecnologia Java ME (ver seção Links). Assim como as outras edições Java, é necessário ter instalado o JDK (Java Development Kit), portanto siga as instruções da página de download do NetBeans IDE. Com o NetBeans instalado você estará apto a desenvolver aplicações com a tecnologia Java ME e

executá-las em emuladores do Java ME SDK 3, que acompanham a IDE.

Construindo a aplicaçãoNo menu Arquivo, selecione Novo Projeto, escolha a categoria Java ME e um projeto de

Aplicativo móvel, leia a descrição e clique em Próximo. Na próxima tela dê um nome ao projeto e desmarque a opção Criar MIDlet Olá. A tela que segue apresenta os emuladores, configurações e perfis que o projeto pode ter, selecione o emulador DefaultCldcPhone1, CLDC-1.1, MIDP-2.0 e finalize a criação do projeto.Agora clique com o botão direito do mouse em Pacotes de código fonte e crie um novo pacote

(com.javamovel.midlet). Dentro do pacote selecione Novo > MIDlet e dê o nome de MIDletHello.java. O MIDlet criado já possui os três métodos padrões, mostrados na Listagem 1.

Listagem 1. Conteúdo do arquivo MIDletHello.java.package com.javamovel.midlet;

import javax.microedition.midlet.*;

public class MIDletHello extends MIDlet { public void startApp() { }

public void pauseApp() { }

public void destroyApp(boolean unconditional) { }}

Conforme mencionado anteriormente, iniciamos a aplicação através do método startApp() obtendo uma instância do objeto Display para capturar as características do aparelho, depois definimos qual objeto Displayable (Tela) será mostrado. O método getMainForm(), cria um novo objeto Form caso ainda não tenha sido instanciado. Um objeto do tipo Form é composto por um título e um conjunto de Items. Em nosso exemplo,

o formulário é composto por uma string e uma imagem, que são obtidos respectivamente pelos métodos getStringItem() e getImageItem(). Além dos itens, o formulário possui dois comandos, um para exibir uma lista de Clientes e outro para sair da aplicação.Como a aplicação possui comandos que geram eventos o MIDlet precisa implementar a classe

CommandListener e seus métodos abstratos. Os eventos são disparados através do método commandAction(), onde são tratadas as ações para cada comando. A Listagem 2 mostra como o código ficou até o momento.

Listagem 2. Conteúdo do arquivo MIDletHello.java (Form principal).package com.javamovel.midlet;

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

public class MidletHello extends MIDlet implements CommandListener { private Display display; private Form mainForm; private StringItem stringItem; private ImageItem imageItem; private Image imageJavaMovel; private Command clientCommand, exitCommand;

public StringItem getStringItem() { if (stringItem == null) { stringItem = new StringItem("Hello Java ME", null); } return stringItem; }

public Image getImage() { if (imageJavaMovel == null) { try { imageJavaMovel = Image.createImage("/com/javamovel/midlet/imgJM.PNG"); } catch (java.io.IOException e) { e.printStackTrace(); } } return imageJavaMovel; }

public ImageItem getImageItem() { if (imageItem == null) { imageItem = new ImageItem("", getImage(), ImageItem.LAYOUT_DEFAULT, null); } return imageItem; }

public Command getClientCommand() { if (clientCommand == null) { clientCommand = new Command("Clientes", Command.OK, 0);

} return clientCommand; }

public Command getExitCommand() { if (exitCommand == null) { exitCommand = new Command("Sair", Command.EXIT, 0); } return exitCommand; }

public Form getMainForm() { if (mainForm == null) { mainForm = new Form("Welcome", new Item[] { getStringItem(), getImageItem() }); mainForm.addCommand(getClientCommand()); mainForm.addCommand(getExitCommand()); mainForm.setCommandListener(this); } return mainForm; }

public void exitMIDlet() { destroyApp(true); notifyDestroyed(); }

public void startApp() { display = Display.getDisplay(this); display.setCurrent(getMainForm()); }

public void pauseApp() { }

public void destroyApp(boolean unconditional) { }

public void commandAction(Command command, Displayable displayable) { if (displayable == mainForm) { if (command == exitCommand) { exitMIDlet(); } else if (command == clientCommand) { display.setCurrent(getClientList()); } } } }

A ação definida pelo objeto clientCommand mostra um novo componente da classe Screen no Display, um List do tipo IMPLICIT que permite ao usuário selecionar uma das opções, obtido pelo método getClientList(). Nesta lista são adicionados dois elementos, neste exemplo são clientes, e dois comandos, um para voltar para a tela anterior e outro para selecionar um cliente da lista, a fim de exibir seus dados pessoais. A Listagem 3 mostra como construir esta lista.

Listagem 3. Conteúdo do arquivo MIDletHello.java (List).package com.javamovel.midlet;

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

public class MidletHello extends MIDlet implements CommandListener {

/*Declarações da Listagem 2*/

private List clientList; private Command selectCommand, backCommand;

public Command getSelectCommand() { if (selectCommand == null) { selectCommand = new Command("Selecionar", Command.OK, 0); } return selectCommand; } public Command getBackCommand() { if (backCommand == null) {

backCommand = new Command("Voltar", Command.BACK, 0); } return backCommand; } public List getClientList() { if (clientList == null) { clientList = new List("list", Choice.IMPLICIT); clientList.append("Roberto", null); clientList.append("Carlos", null); clientList.addCommand(getSelectCommand()); clientList.addCommand(getBackCommand()); clientList.setCommandListener(this); } return clientList; }

/*Métodos da Listagem 2*/

public void commandAction(Command command, Displayable displayable) {

/*Ações definidas na Listagem 2*/

if (displayable == clientList) { if (command == backCommand) { display.setCurrent(getMainForm()); } else if (command == selectCommand) { display.setCurrent(getClientForm()); } }}

Para exibir os dados do cliente foi construído um novo formulário com os componentes TextField, DateField, ChoiceGroup (EXCLUSIVE e MULTIPLE) e um Alert para exibir uma mensagem de confirmação, conforme a Listagem 4. Parte do resultado da aplicação pode ser visualizado na Figura 4.

Listagem 4. Conteúdo do arquivo MIDletHello.java (Form Cliente)package com.javamovel.midlet;

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

public class MidletHello extends MIDlet implements CommandListener {

/*Declarações das Listagens 2 e 3*/

private Form clientForm; private TextField textField; private DateField dateField; private ChoiceGroup genderChoiceGroup, professionalAreaChoiceGroup; private Command updateCommand; private Alert alert;

public TextField getTextField() { if (textField == null) { textField = new TextField("Nome", "Nome Cliente", 32, TextField.ANY); } return textField; }

public DateField getDateField() { if (dateField == null) { dateField = new DateField("Data", DateField.DATE_TIME); dateField.setDate(new java.util.Date(System.currentTimeMillis())); } return dateField; }

public ChoiceGroup getGenderChoiceGroup() { if (genderChoiceGroup == null) { genderChoiceGroup = new ChoiceGroup("Sexo:", Choice.EXCLUSIVE); genderChoiceGroup.append("Masculino", null); genderChoiceGroup.append("Feminino", null); genderChoiceGroup.setSelectedFlags(new boolean[] { true, false }); }

return genderChoiceGroup; }

public ChoiceGroup getProfessionalAreaChoiceGroup() { if (professionalAreaChoiceGroup == null) { professionalAreaChoiceGroup = new ChoiceGroup("Area da Profissao", Choice.MULTIPLE); professionalAreaChoiceGroup.append("Esporte", null); professionalAreaChoiceGroup.append("TI", null); professionalAreaChoiceGroup.append("Agricultura", null); professionalAreaChoiceGroup.setSelectedFlags(new boolean[] { false, true, false }); } return professionalAreaChoiceGroup; }

public Command getUpdateCommand() { if (updateCommand == null) { updateCommand = new Command("Atualizar", Command.OK, 0); } return updateCommand; }

public Form getClientForm() { if (clientForm == null) { clientForm = new Form("", new Item[] { getTextField(), getDateField(), getGenderChoiceGroup(), getProfessionalAreaChoiceGroup() }); clientForm.addCommand(getUpdateCommand()); clientForm.addCommand(getBackCommand()); clientForm.setCommandListener(this);

} return clientForm; }

public Alert getAlert() { if (alert == null) { alert = new Alert("", "Atualizado com Sucesso!", null, null); alert.addCommand(getBackCommand()); alert.setCommandListener(this); alert.setTimeout(Alert.FOREVER); } return alert; }

/*Métodos das Listagens 2 e 3*/

public void commandAction(Command command, Displayable displayable) {

/*Ações definidas nas Listagens 2 e 3*/

if (displayable == clientForm) { if (command == backCommand) { display.setCurrent(getClientList()); } else if (command == updateCommand) { display.setCurrent(getAlert(), getClientList()); } } if (displayable == alert) { if (command == backCommand) { display.setCurrent(getClientList()); } } }}

Figura 4. Tela CientForm.

ConclusõesA intenção deste artigo foi apresentar o Java ME de forma que os desenvolvedores tenham

conhecimento de como a plataforma funciona, desde sua estrutura até a utilização dos principais componentes de interface. A aplicação desenvolvida não visa uma lógica de negócios, mas sim mostrar aos iniciantes em Java ME como construir interfaces com o usuário para dar início na implementação da sua própria aplicação.

Lais Zanfolim (laiszanfolim@gmail.com)Rodolfo Chaves Fernandes (chavesrodolfo@gmail.com)

http://www.javamovel.com