J2ME MIDP:Os Primeiros Passos para o Desenvolvimento de Aplicativos para Celulares.

Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login
Confirmar voto
0
 (2)  (0)

O objetivo desse artigo é inserir o leitor no mundo do desenvolvimento de aplicações em J2ME MIDP.

J2ME MIDP:

Os Primeiros Passos para o Desenvolvimento de Aplicativos para Celulares

Gabriel Fernando Andriolli

O objetivo desse artigo é inserir o leitor no mundo do desenvolvimento de aplicações em J2ME MIDP. Primeiramente são apresentados alguns conceitos básicos dessa plataforma (secção 1). Em seguida o leitor irá aprender a obter e instalar as ferramentas de desenvolvimento (secção 2). Será apresentado o J2ME Wireless Toolkit (secção 3) com a qual o leitor irá aprender a criar, compilar e testar projetos de aplicativos e entender como são organizados os arquivos de cada projeto. Será mostrado ainda, de forma sucinta, o ciclo de vida de uma MIDlet e como é estruturado o seu código (secção 4). Por fim, serão tecidas as conclusões (secção 5) e apresentadas algumas referências.

Esse artigo destina-se às pessoas que já possuem algum conhecimento em Java e pretendem iniciar seus estudos em J2ME.

1. J2ME (Java 2 Micro Edition)

 

O J2ME é uma plataforma composta por uma coleção de tecnologias e especificações designadas a dispositivos móveis. O J2ME pode ser visto como uma simplificação do J2SE (Standard Edition) com algumas modificações para possibilitar que Java rode em dispositivos com capacidade limitada, como é o caso dos celulares, pagers, e outros pequenos dispositivos.

 

Arquitetura do J2ME

A arquitetura do J2ME é composta por três partes: Configurators, Profiles e pacotes extras. Em um nível mais baixo, ela é dividida em dois Configurators. A cada Configurator estão associados Profiles e ainda podem ser acrescentados pacotes extras para prover funcionalidades mais específicas.

Os Configurators são compostos por uma VM (Máquina Virtual) e algumas classes que fornecem as funcionalidades mais básicas dos dispositivos. Os dois tipos de Configurators existentes até agora são:

·        Connected Limited Device Configuration (CLDC): para dispositivos bem simples, com memória maior do que 160 KB e processador mínimo de 16MHz, tais como celulares e palms.

·        Connected Device Configuration (CDC): para dispositivos com memória superior a 2 MB, tais como PDAs e algumas televisões de terceira geração.

A Figura 1 mostra a arquitetura do J2ME e a divisão entre os dois Configurators.

Os Profiles podem ser vistos como uma especialização de um Configurator. São um conjunto de APIs que definem funções de mais alto nível para uma determinada família de dispositivos.

O Profile que vamos usar nesse tutorial é o MIDP (Mobile Information Device Profile), que tem como base o CLDC. Ele fornece funcionalidades para o desenvolvimento de aplicativos para uma grande variedade de celulares e é atualmente a tecnologia mais usada para desenvolvimento de aplicativos para esses dispositivos. Os aplicativos desenvolvidos com base no MIDP, como os que serão apresentados nesse artigo, são chamados de MIDlets.

Os pacotes opcionais são usados quando se necessita de funcionalidades extras, como de tecnologias como Bluetooth, banco de dados e envio de mensagens.

Figura 1 - Arquitetura do J2ME.

2. Ferramentas para o desenvolvimento com J2ME MIDP

 

Antes de iniciar o desenvolvimento é necessário dispor de três ferramentas:

·        Um editor de texto, para editar o código. Algumas alternativas são o Bloco de Notas, o VIM ou o jEdit (www.jedit.org);

·        Java 2 Standard Edition (J2SE) SDK, versão 1.4.2 ou superior. Disponível em http://java.sun.com/j2se/. Basta fazer o download de acordo com o sistema operacional e executar o arquivo de instalação;

·        Um ambiente de desenvolvimento com suporte a J2ME MIDP. Nesse artigo vamos usar o J2ME Wireless Toolkit, disponível para Windows e Linux no endereço http://java.sun.com/products/j2mewtoolkit/.

 

Existem muitos ambientes que suportam MIDP, como o JBuilder e o Code Warrior Wireless Studio. Neste artigo vamos usar o J2ME Wireless Toolkit, da Sun Microsystems, que é um conjunto de ferramentas para o desenvolvimento de aplicações J2ME baseadas em CLDC e MIDP. O J2ME Wireless Toolkit inclui ambiente de compilação, depuração, testes, otimização de desempenho, documentação e exemplos, automatizando uma série de tarefas comuns do processo de desenvolvimento.

3. Como usar o J2ME Wireless Toolkit

 

Feita a instalação, observe que os arquivos do J2ME Wireless Toolkit vão para um diretório chamado WTK2 (c:\WTK2, no Windows), a menos que seja especificado um nome diferente. Nesse diretório é relevante observar:

1.      O arquivo index.html, que contém links para a documentação do Toolkit e para a API do MIDP. Muito útil durante o desenvolvimento e estudo;

2.      O diretório apps, onde são armazenados os projetos;

3.      O diretório bin, onde estão os executáveis do Toolkit, dentre outros arquivos.

 

Durante a instalação também são criados atalhos para algumas partes do Toolkit. Execute o atalho para o KToolbar. Deve ser mostrada uma janela como ilustra a Figura 2.

 

Figura 2 - Janela inicial do J2ME Wireless Toolkit.

 

            Clique no botão Open Project.... Será mostrada uma lista de todos os aplicativos disponíveis. Escolha um deles e clique no botão Open Project.

            Uma vez que a aplicação foi aberta, pressione o botão Run. O aplicativo será executado em um emulador, no qual você pode testar o aplicativo.

            O J2ME Wireless Toolkit trabalha com projetos cujo produto final é gerar MIDlets. Para criar um projeto, clique no botão New Project.... Será solicitado que o usuário entre com o nome do projeto e o nome da classe principal da MIDlet. Para um primeiro exemplo, coloque o nome do projeto de PrimeiroProjeto e o nome da classe de PrimeiraMIDlet, como mostrado na Figura 3.

 

Figura 3 - Criação de um novo projeto.

 

            Uma vez preenchidos os nomes do projeto e da classe, o Toolkit mostra uma tela onde é possível configurar algumas propriedades do projeto. Apenas aceite as configurações apresentadas. Esse assunto não será tratado neste artigo.

            O Toolkit armazena cada projeto no diretório apps, em um subdiretório com o mesmo nome do projeto. Para o projeto criado anteriormente, o Toolkit criou, no meu computador, o subdiretório c:\WTK2\apps\PrimeiroProjeto, que tem a estrutura padrão mostrada na figura 4.

 

Figura 4 - Estrutura do diretório de um projeto.

 

            O diretório bin (binaries) contém um arquivo JAR gerado a partir das MIDlets compiladas e um arquivo JAD, que contém uma descrição do MIDlet. O diretório lib (libraries) deve armazenar qualquer arquivo JAR adicional ao projeto. O diretório res (resources) deve armazenar os recursos do projeto, tais como imagens e arquivos texto. Finalmente, o diretório src (sources) é onde os arquivos de código devem ser armazenados.

            Quando o projeto é compilado, o Toolkit cria alguns outros diretórios para uso interno.

          O próximo passo é escrever o código fonte da MIDlet. Use o seu editor de texto para escrever o código mostrado na Listagem 1. Por hora não vamos nos preocupar com o entendimento do código. Esta descrição será feita mais adiante.

 

Listagem 1 - Código fonte da PrimeiraMIDlet.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import javax.microedition.lcdui.*;
import javax.microedition.midlet.*;
 
public class PrimeiraMIDlet extends MIDlet implements CommandListener {
  private Form meuForm;
  
  public PrimeiraMIDlet() {
    meuForm = new Form("PrimeiraMIDlet");
    meuForm.append("Minha PrimeiraMIDlet Funciona!");
 
    Command exitCommand = new Command("Exit", Command.EXIT, 0);
    meuForm.addCommand(exitCommand);
    meuForm.setCommandListener(this);
  }
  
  public void startApp() {
    Display.getDisplay(this).setCurrent(meuForm);
  }
  
  public void pauseApp() {}
  
  public void destroyApp(boolean unconditional) {}
  
  public void commandAction(Command cmd, Displayable dis) {
    notifyDestroyed();
  }
}

 

Salve o arquivo com o nome de PrimeiraMIDlet.java no diretório src do projeto (no meu computador fica em c:\WTK2\apps\PrimeiroProjeto\src\PrimeiraMIDlet.java).

Pressione o botão Build no KToolbar e espere compilar. Corrija os erros, caso algum ocorra, até compilar o projeto. Em seguida, pressione o botão Run para testá-lo. Você deverá ver um emulador de telefone celular semelhante ao mostrado na Figura 5. Selecione a opção Launch no emulador para executar a MIDlet. O resultado deve ser o apresentado na Figura 6.

            Um projeto comporta quantas MIDlets se queira. Para adicionar uma nova MIDlet ao projeto, pressione o botão Settings... no KToolbar. Vai aparecer uma janela onde você deverá ir à guia MIDlets. Edite os campos usando os botões Add e Edit como mostrado na Figura 7.

 

 

Figura 5 - O emulador mostra a lista de MIDlets carregadas. No caso, só uma.

 

  

 

Figura 6 - PrimeiraMIDlet rodando no emulador.

 

 

Figura 7 - Adicionando MIDlets ao projeto

 

            Agora será necessário escrever o código fonte da SegundaMIDlet, o que significa gerar o arquivo SegundaMIDlet.java e salvá-lo no diretório src do projeto. Para efeito de teste, você pode apenas copiar o código mostrado anteriormente, substituir todas as ocorrências de “PrimeiraMIDlet” por “SegundaMIDlet” e salvar o arquivo como c:\WTK2\apps\PrimeiroProjeto\src\SegundaMIDlet.java.

Compile o projeto e em seguida execute-o para ver o resultado no emulador.

            Na janela da Figura 7 pode-se ainda configurar o ícone de cada MIDlet. O campo Icon deve ser preenchido com o caminho até o ícone da respectiva MIDlet. O KToolbar assume que os caminhos são dados relativos a partir do diretório res do projeto. Assim, para o exemplo da Figura 7, nomeie dois arquivos de imagem para icon1.png e icon2.png e salve-os no diretório c:\WTK2\apps\PrimeiroProjeto\res\icons.

            Compile o projeto e em seguida execute-o para ver o resultado no emulador. A tela do emulador deve ser parecida com a mostrada na Figura 8, dependendo das imagens dos ícones.

 

Figura 8 - Duas MIDlets no mesmo projeto, cada qual com um ícone.

4. Entendendo as MIDlets

 

Agora que já tivemos alguma diversão, vamos entender melhor o que é e como funciona uma MIDlet.

Uma MIDlet é um aplicativo MIDP. Assim como uma Applet é gerenciada por um brownser, uma MIDlet é gerenciada por um software chamado AMS (Application Management Software), presente em cada dispositivo.

Mais tecnicamente, a classe principal de uma MIDlet deve estender a classe javax.microedition.midlet.MIDlet, como pode ser visto na linha 4 do código apresentado na Listagem 1. Nessa classe principal devem ser definidos três métodos: startApp(), pauseApp() e destroyApp(); os quais definem os três estados possíveis do ciclo de vida de uma MIDlet. Estes estados são:

 

·        Pausado – É o estado inicial da MIDlet, assumido assim que ela começa a ser construída pelo AMS. O AMS também pode levar a MIDlet para este estado quando ela estiver no estado Ativo, como, por exemplo, para atender o telefone ou receber SMS. Nesse caso, o AMS invoca o método pauseApp();

·        Ativo – O AMS pode invocar o método startApp() para mudar o estado da MIDlet de Pausado para Ativo. Isso acontece, por exemplo, enquanto o AMS invoca o construtor da MIDlet na inicialização do aplicativo.

·        Destruído – A execução termina e os recursos são liberados (é chamado o garbage collector). A MIDlet pode ser destruída a partir de qualquer estado.

 

A Figura 9 ilustra o ciclo de vida de uma MIDlet.

 

Figura 9 - Ciclo de vida de uma MIDlet.

 

Tendo em vista o ciclo de vida mostrado na Figura 9, o esqueleto do código de uma MIDlet é semelhante ao código da Listagem 2, abaixo.

Quando uma MIDlet estiver para ser colocada no estado de Ativa, o MAS chamará startApp(). Isso pode acontecer muitas vezes durante o ciclo de vida do aplicativo. Portanto, é importante pensar bem sobre o que será executado quando o método startApp() for chamado. Muitas vezes, esse método não necessita fazer mais do que tornar visível um objeto da classe Displayable[1] (Listagem 1, linha 17). Código que precisa ser iniciado e persistir por toda a vida da MIDlet deve ser colocado no construtor, que será executado uma única vez.

Com relação ao código da Listagem 1, observa-se a mesma estrutura apresentada na Listagem 2. Percebe-se, porém, algumas diferenças:

·        Na linha 1, são importadas as classes do pacote javax.microedition.lcdui. Este pacote define classes para a implementação das GUIs (Graphical User Interface) das MIDlets. As classes Canvas, Display, Form e Command, por exemplo, pertencem a esse pacote.

·        Na linha 4, a classe principal do MIDlet implementa CommandListener, que é uma interface para tratar de comandos de alto nível. O método commandAction dessa interface é definido na linha 24.

·        Na linha 8 é inicializada uma instância da classe Form. Essa classe define métodos para gerenciar a GUI e a interação com o usuário. Por exemplo, na linha 9 é adicionada à GUI a frase “Minha PimeiraMIDlet funciona!”, a ser mostrada na tela do aparelho quando o aplicativo for executado. Na linha 12 é adicionado o comando para iteração com o usuário criado na linha 11.

·        Na linha 13 é definido o Listener para os eventos gerados pelo usuário. No caso, o Listener é a própria classe, uma vez que ela implementa CommandListener.

·        Na linha 17, o método setCurrent() aplicado ao objeto Dysplay, determina o objeto da classe Displayable que será visível na tela do aparelho. Nesse caso, é passado um objeto da classe Form, que é derivada da classe Screen que, por sua vez, é derivada de Displayable.

 

Listagem 2 - Código básico de uma MIDlet.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import javax.microedition.midlet.*;
 
public class BasicaMIDlet extends MIDlet {
  public BasicaMIDlet(){
    // Construtor – para eventuais inicializações
  }
 
  protected void startApp()
            throws MIDletStateChangeException {
    // Chamado quando a MIDlet é ativada
  }
 
  protected void pauseApp(){
    // Chamado quando a MIDlet é pausada
  }
 
  protected void destroyApp( boolean unconditional )            
            throws MIDletStateChangeException {
    // Chamado para destruir a MIDlet
  }
}

 

5. Conclusões

 

Neste artigo foram apresentadas informações básicas para a iniciação ao desenvolvimento de aplicativos na plataforma J2ME. Em um primeiro momento, foram apresentados os conceitos dessa plataforma e o contexto em que se encontram os aplicativos para celulares. As ferramentas para o desenvolvimento foram apresentadas em seguida com enfoque para o J2ME Wireless Toolkit, para o qual foram resumidas as suas funcionalidades básicas, tais como criar, compilar e testar projetos. Foi ainda apresentado o ciclo de vida de uma MIDlet e explicado os pontos-chave do código de um aplicativo simples.

        Agora você aprendeu a base do desenvolvimento de aplicações em MIDP e possui as ferramentas necessárias para o desenvolvimento de MIDlets. Mas para produzir aplicativos mais funcionais você precisa se aprofundar em alguns assuntos como, por exemplo, desenvolvimento de jogos, BlueTooth e serviços de Internet. Algumas referências são apresentadas nos links abaixo.

 

Links

http://java.sun.com/j2me

Site oficial do J2ME na Sun

http://developers.sun.com/techtopics/mobility/learn/midp/getstart/

Diversos artigos sobre MIDP

http://www.jasonlam604.com

Diversos artigos e tutoriais. J2ME, MIDP, BlueTooth

http://sourceforge.net/projects/j2megamingbook/

Livro para desenvolvimento de jogos para com enfoque em MIDP 2.0

 

Gabriel Fernando Andriolli (gabriolli@gmail.com) tem mais de 5 anos de experiência em Java e C++ e 3 anos em administração de rede Unix. Projetou e implementou diversos sistemas computacionais voltados para a engenharia, integrando técnicas de inteligência artificial, programação em tempo real e sistemas distribuídos. Publicou vários artigos sobre esses trabalhos. Iniciou-se no mundo wireless em 2002, com o WML. Atualmente é engenheiro de desenvolvimento tecnológico da Embraer onde desenvolve aplicativos em VB.NET, Java e ColdFusion.


[1] Displayable é uma classe abstrata da qual derivam classes que definem componentes gráficos que podem ser vistos na tela de um dispositivo. Exemplo,  TextBox, Form, DateField, ImageItem, entre outras.

 
Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Ficou com alguma dúvida?