Iniciando em J2ME: Analisando o código Hello World

Continuando o último post (Iniciando em J2ME: Desenvolvendo o Hello World), vamos explicar agora todo o código fonte gerado pelo editor visual do Netbeans, para o código do Hello World.

O código ficou o seguinte:


A classe HelloMIDlet extende MIDlet (é um código java de aplicativo móvel) e implementa CommandListener, que é a classe responsável pelos comandos, no caso o CommandExit, que sai do aplicativo.

Em General Fields: estão as declarações necessárias.

private Command exitCommand; // o comando Sair
private Form form; //o form utilizado
private StringItem stringItem; //o item de string com Hello e Hello World

Em Generated Method: startMIDlet - função startMIDlet, é onde escrevemos como deve iniciar a aplicação.

public void startMIDlet(){
switchDisplayable(null,getForm());
}

No caso a aplicação inicia com o comando switchDisplayable, que exibe um display (tela). O primeiro parâmetro é de onde esta vindo (de que tela) e o segundo para que tela quer ir, que tela quer mostrar, no caso a tela form, que é obtida através da função getForm().

Em Generated Method: switchDisplayable - função que retorna qual tela mostrar, de acordo com os parâmetros mandados, como vimos acima.

Em Generated Method: commandAction for Displayables - implementação dos comandos usados na aplicação.

public void commandAction(Command command, Displayable displayable){
if (displayable == form){
  if (command == exitCommand){
      exitMIDlet(); 
  }
}
}

No displayable form está o comando exit (exitCommand) que quando selecionado executa o código determinado, no caso o exitMIDlet, que encerra a aplicação.

Em Generated Getters: exitCommand - código que cria e retorna o exitCommand.

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

exitCommand recebe um novo comando. Os parâmetros são o nome, que vai aparecer na tela, o tipo do comando, no caso EXIT e a prioridade do comando.

Em Generated Getters: form - código que cria e retorna o form.

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

O form recebe um novo form e os parâmetros definem como este vai ser. O primeiro parâmetro é o título, o segundo são os itens que este possui. Entre chaves está o método que retorna cada item.

Em uma tela (form, list ou outro) podem ter vários itens. Para mostrar quais são os itens e screens (telas) vejamos a figura abaixo que define a hierarquia de componentes do J2ME.


Continuando o código da função getForm() temos a linha:

form.addCommand(getExitCommand());

Corresponde ao ExitCommand que está sendo adicionado ao form e em

form.setCommandListener(this);

informamos que neste form existe um evento.

Em Generated Getters: stringItem - código que cria e retorna este item de string.

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

stringItem recebe um novo StringItem e os parâmetros são os textos que vão aparecer na tela, no primeiro campo e no segundo.

Depois disso temos a função getDisplay() que retorna uma instância da classe Display, a qual serve para a MIDlet acessar as informações do dispositivo em que esta sendo executada. Estas informações são referentes ao tamanho da tela, disposição de botões, cores, entre outros.

public Display getDisplay () {
return Display.getDisplay(this);
}

Em seguida a função exitMIDlet() - encerra o aplicativo.

public void exitMIDlet() {
switchDisplayable (null, null);
destroyApp(true);
notifyDestroyed();
}

Primeiro é setado null (nada) para ser exibido na tela.
Depois é destruída a aplicação e essa ação é notificada ao gerenciador.

Os próximos 3 métodos são obrigatórios para o MIDlet e serão criados sempre que criar um novo MIDlet.

O primeiro: startApp é chamado automaticamente quando a plicação é executada.
Se você não clicar em iniciar (launch) a aplicação ficará no estado pausado (resumeMIDlet).
Se você iniciar a aplicação isto vai ser notificado e o starMIDlet será chamado para executar a(s) primeira(s) ação(ões) desejada(s).
Como o MIDlet está em execução o midletPaused é setado como falso.

public void startApp() {
if (midletPaused) {
   resumeMIDlet ();
} else {
   initialize ();
startMIDlet ();
}
midletPaused = false;
}

O segundo método é para quando a aplicação for pausada. O midletPaused é setado como verdadeiro.

public void pauseApp() {
midletPaused = true;
}

E o último método é para destruir a aplicação. Pode ser passado true ou false como parâmetro. O false seria usado para gerar uma exceção quando o usuário optar por sair, para o gerenciador ver se o aplicativo pode ser fechado. O true diz que a aplicação será fechada independente de qualquer coisa, mesmo que algum processo ainda esteja sendo executado.

public void destroyApp(boolean unconditional) {
}

Terminada a análise do código! Qualquer dúvida é só entrar em contato.