Programando para a plataforma Symbian com Java Me

O Java ME é uma das plataformas mais comuns em dispositivos móveis. Por permitir a implementação de serviços avançados e ricos (por exemplo, serviços de localização e comércio sem-fio) ganhou reconhecimento como uma plataforma sólida para provedores de conteudo. Nesse artigo, será mostrado como começar a desenvolver aplicativos nessa plataforma, com foco no sistema Symbian.

Tecnologia e linguagem Java

A tecnologia Java é uma coleção de produtos e especificações de software  da Sun Microsystems (hoje, Oracle), que fornece uma sistema para desenvolvimento de aplicações multi-plataforma.

A linguagem de programação Java foi introduzida pela Sun em 1995 e foi projetada para uso em ambientes distribuidos da Internet. Foi criada de modo a ter uma notação similar a C++, mas com maior simplicidade e um paradigma orientado a objeto único.

A linguagem Java pode ser caracterizada pelos seguintes itens:

•    Portabilidade – aplicações Java são capazes de ser executadas em uma ampla variedade de arquiteturas de hardware e sistemas operacionais.
•    Robustez – ao contrário de programas escritos em C++, as instruções de Java não podem causar crashes no sistema.
•    Segurança – caracteristicas de segurança foram projetadas na linguagem e no sistema de execução.
•    Orientação a objeto – com a exceção dos tipos primitivos, tudo em Java é um objeto e suporta encapsulamento e passagem de mensagens, paradigmas de software orientado a objetos.
•    Multithread – a linguagem Java suporta multithreading e tem primitivas de  sincronização construidas dentro da linguagem.
•    Simples e familiar – isso naturalmente é relativo a linguagem C++. Não imagine que Java possa se aprendida em 1 dia.
Em Java, o código fonte é escrito em arquivo .java que são compilados em arquivos .class pelo compilador. Uma arquivo .class contém instruções neutras de arquitetura (bytecode) que são a linguagem da máquina virtual Java (JVM).

Plataformas Java

Uma plataforma Java é uma plataforma de software que roda sobre uma plataforma nativa, sendo essa a combinação entre o sistema operacional e o hardware equivalente. Uma plataforma Java é divida em dois componentes:
•    A JVM que executa o bytecode da linguagem Java – pode ser portada para várias plataformas.
•    A coleção de API´s de Javaa – bibliotecas de software prontas para uso que fornecem diversos recursos de desenvolvimento.
Juntas, a JVM e a API rodam uma aplicação de uma plataforma nativa.a Existem três plataformas Java principais que tem como alvo diferentes ambientes:

•    Java Platform Micro Edition (Java ME) — ambientes móveis com recursos limitados
•    Java Platform Standard Edition (Java SE) — ambientes corporativos
•    Java Platform Enterprise Edition (Java EE) —todos os outros ambientes em geral.

O próposito desse tutorial é dar uma olhada no Java ME e explicar como desenvolver sua primeira aplicação.

Plataforma Java Platform Micro Edition (Java ME)

O Java ME é hoje a plataforma número 1 para jogos sem-fio por volume de vendas. O Java ME é a plataforma que permite aos programadores usar a linguagem e ferramentas Java para desenvolver aplicações para dispositivos móveis como telefones celulars e PDA´s. O Hava MNE é sub-dividido em Configurações, Perfis e pacotes opcionais.

Uma COnfiguração é uma especificação da JVM  e uma conjunto básico de bibliotecas de classe necessárias; geralmente é uma sub-conjunto das API´s da J2SE. Atualmente, existem duas Configurações de Java ME:
•    Connected Limited Device Configuration (CLDC)

•    Connected Device Configuration (CDC).

Um Perfil se apoia sobre uma Configuração para completar o ambiente de execução, pela adição de mais algumas API´s de alto nivel, que enquadram o dispositivo em uma categoria especifica. Atualmente, existem dois perfis para o Java ME:
•    Mobile Information Device Profile 1.0 (MIDP1)

•    Mobile Information Device Profile 2.0 (MIDP2).
Uma padrão largamente adotado é a combinação do MIDP com o CLDC para fornecer uma plataforma Java completa para telefones celulares e dispositivos similares.

Pacotes opcionais adicionam funcionalidades a plataforma Java ME ao oferecer API´s para uso de várias tecnologias, como banco de dados, conectividade, webservices, gráficos 3d e muito mais.

A plataforma Java ME do Symbian

O SymbianOS suporta os seguintes padrões do Java ME:

•    CLDC 1.1 – Uma revisão retro-compativel com o CLDC 1.0 com algumas adições como o suporte a matemática de ponto flutuante.

•    MIDP 2.0 – Versão retro-compativel com a MIDP 1.0 com novoas recursos tais como funcionalidades para jogos e multimidia, interface com o usuário, conectividade extensiva, OTA e uma modelo de segurança robusto.

•    Grande coleção de APIs opcionais – como WMA, Arquivos e acesso ao PIM, Bluetooth, gráficos 3d e multimidia avançada.

•    Acesso ilimitado aos recursos do sistema – heap, threads, etc.

•   Depuração no próprio dispositivo.

O que é necessário?

Para começo de conversa, você precisa de software de desenvolvimento para escrever o seu código e compila-lo. O melhor jeito para isso é usar uma IDE (ambiente de desenvolvimento integrado, em inglês), que contém editor, compilador e outras ferramentas. o NetBeans é uma IDE de código aberto que fornece aos desenvolvedores todo o necessário para criar aplicações Java. Quando você baixa o NetBeans, você obtém uma IDE modular e baseada nos padrões com todas as funcionalidades principais.

Para desenvolvimento em Java ME você precisa integrar o NetBeans Mobility PAck ao IDE, que pode ser usado para escrever, testar e depurar aplicações para dispositivos MIDP 2.0 / CLDC 1.1. Permite também integrar outros SDK´s de vários fornecedores de dispositivos móveis – e é isso que faremos.

Você pode baixar o Instalador do NetBeans IDE 5.0 do site www.netbeans.org/community/releases/50. Quando a instalação for concluida, você pode baixar o NetBeans Mobility Pack 5.0 na mesma URL. Você terá depois disso uma IDE para desenvolvimento de alicações Java ME.

O outro software necessário é uma Kit de Desenvolvimento do MIDP (SDK), que permite  escrever e c0mpilar aplicações para seu telefone. Existem vários SDK´s disponíveis, dependendo do telefone alvo.

Se você não tiver um modelo particular de telefone ou uma plataforma em mente e não tem certeza de qual SDK escolher, é recomendado que você começe com um SDK para o S60 e o UIQ. Ambas as opções são para o Symbian v9 (isto é, UIQ3 e S60 3ª edição); para escrever aplicações para outros telefones  como o Nokia E e N series, ou Sony-Ericsson P990i, procure pelas versões UIQ 2.1 e S60 2ª edição FP2.

Onde encontrar?

Essa seção especifica onde encontrar os recursos discutidos na seção anterior.

IDEs:

• NetBeans www.netbeans.org/community/releases/50
• Eclipse www.eclipse.org/downloads

SDKs:

•    S60 Platform SDKs for Symbian OS, for Java
www.forum.nokia.com/main/resources/tools_and_sdks/listings/java_tools.html

• Carbide.j
www.forum.nokia.com/main/resources/tools_and_sdks /carbide/index.html
• UIQ3.0 www.developer.uiq.com/devtools_uiqsdk.html
•    SEMC SDK for the Java ME platform www.developer.sonyericsson.com/site/global/docstools/java/p_java.jsp
• WTK www.java.sun.com/products/sjwtoolkit

Uma aplicação HelloWorld explicada

A unidade de execução no MIDP é o MIDlet. É similar ao Applet, mas nesse caso atende aos padrões especificados pelo CLDC e MIDP e roda em dispositivos moveis. Abaixo segue um exemplo de um HelloWorld que fornece uma rápida visão geral de uma aplicação MIDP minima.

import javax.microedition.midlet.MIDlet;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.TextBox;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;

/**
* Hello, World example
*/

public class HelloWorld extends MIDlet implements CommandListener {

   /** * Exit command */
   private Command iExitCommand;

   /** * MIDlet constructor */
   public HelloWorld() {
      iExitCommand = new Command("EXIT", Command.EXIT, 1);
   }

   /** * Signals the MIDlet that it has entered the Active state.*/
   public void startApp() {
      TextBox textBox = new TextBox("Hello World", "Hello, World!", 256, 0);
      textBox.addCommand(iExitCommand);
      textBox.setCommandListener(this);
      Display.getDisplay(this),setCurrent(textBox);
   }

   /** * Signals the MIDlet to enter the Paused state.*/
   public void pauseApp() { }

   /** * Signals the MIDlet to terminate and enter the Destroyed state.*/
   public void destroyApp (boolean aUnconditional) { }

   /** * Indicates that a command event has occurred on a Displayable.*/
   public void commandAction(Command aCommand, Displayable aScreen) {
      if (aCommand == iExitCommand) {
         notifyDestroyed();
      }
   }
}

Agora vamos nos aprofundas em cada parte em detalhes.

import

As primeiras seis linhas importam classes especificas do MIDP necessárias pelo exemplo, que são um parte da MIDP com uma sub-conjunto modificadoda linguagem de programação Java:
•    A classe javax.microedition.midlet.MIDlet

•    A interfacejavax.microedition.lcdui.CommandListener

•    classes da interface com o usuário(Existem também declarações implicitas do pacote java.lang.*)

public class HelloWorld extends MIDlet

Essa linha declara que nosso HelloWorld é uma extensão de uma única classe do pacote javax.microedition.midlet.*, a classe MIDlet. Cada aplicação MIDP precisa fornecer uma instância da classe abstrata MIDlet, que sobrecarrega os seguintes três metódos que definem o ciclo de vida do objeto:
• MIDlet.startApp()

• MIDlet.pauseApp()

• MIDlet.destroyApp()

O ciclo de vida do MIDlet ;e bem definido na especificação abaixo.

1.    O Application Management Software (AMS) cria uma nova instância de uma MIDlet e o construtor padrão é chamado.

2. O MIDlet fica no estado Pausado.

3. Quando o AMS decide que o MIDlet deve ser executado, chama startApp() para que o MIDlet possa tomar posse de qualquer recurso que precise para começar a operar. O MIDlet fica no estado Ativo.
4. Quando o AMS determina que o MIDlet não é mais necessário, sinaliza o MIDlet para parar de executar e liberar qualquer recurso que estiver sendo usado através da chamada a destroyuApp(). O MIDlet fica no estado Destruido.

5. Durante a execução do MIDlet, o AMD pode precisar reduzir significativamente a quantidade de recursos consumido pelo mesmo (isso pode ocorrer, por exemplo, quando o telefone recebe uma chamada). O AMS então sinaliza ao MIDlet para reduzir o consumo de recursos chamando o metódo pauseApp() e ele fica no estado Pausado.

implements CommandListener

Essa linha declara que o MIDlet HelloWorld implementa a interface CommandListener que é usada por aplicações que precisam receber eventos de alto nivel da implementação. A interface CommandListener tem um único metódo:

public void commandAction(Command c, Displayable d) – que é invocado pela implementação para indicar que um evento ocorreu em d.

No final do HelloWorld, você pode observar como o MIDlet implementa esse metódo.

private Command iExitCommand

Nessa linha, o MIDlet declara que tem uma variavel membro iExitCommand que é uma referência para uma instância de javax.microedition.lcdui.Command.

Um Command pode ser implementado de várias formas, que tem uma semântica de uma ativação de uma única ação. Isso pode ser uma botão, um item do menu, e possivelmente uma interface de ditado pode ter um Command como uma tag de voz.

public HelloWorld() {

iExitCommand = new Command(“EXIT”, Command.EXIT, 1);
}

Como dito antes, o construtor do HelloWorld será executado antes que o metódo startApp() for chamado. Uma Command contém três partes de informação:

  • um texto
  • um tipo
  • uma prioridade

Em nosso exemplo, o construtor inicializa o iExitCommand para mostrar o texto “EXIT” e ser do tipo Command.EXIT. Isso não significa que quando o usuário chamar esse comando, a aplicação irá sair automaticamente. Apenas quando o CommandListenner.commandAction() é chamado, o MIDlet deve decidir se vai ou não encerrar a execuçao do mesmo.


public void startApp()

Como explicado quando falamos do ciclo de vida do MIDlet, quando o AMS decide que nosso HelloWorld deve rodar, ele chama o metódo startApp(). Nesse metódo o HelloWorld toma posse de qualquer recursos que precisa e então fica no estado Ativo.
TextBox textBox = new TextBox(“Hello World”, “Hello, World!”, 256, 0);

A linha mostra a inicialização da tela TextBox. Todos os objetos que tem a capacidade de ser colocados na tela derivam da classe base Displayable. O MIDP lcdui define duas hierarquias de Displayables:
•    Alto nível – Screen é a super classe comum de todos as classes de interface desse nível. O conteúdo é mostrado e sua interação com o usuário é definida por sub-classes concretas.
•    Baixo nível – Mesmo não sendo o caso aqui nesse exemplo, a segunda hierarquia deriva da classe base Canvas para ativar operações gráficas de baixo nível.

O TextBox em nosso exemplo é uma das sub-classes concretas de Screen, que permite que o usuário entre e edite texto. É criado com “HelloWorld”  como titulo, “Hello, World!” como o conteúdo inicial, 256 caracteres como tamanho máximo e sem permissão para alterações do usuário.

“textBox.addCommand(iExitCommand);”

A linha acima adiciona o iExitCommand à visualização de TextBox. Como explicado sobre formulários de interface com o usuário, a implementação pode escolher adicionar o Command a qualquer botão ou a um menu, dependendo da plataforma do telefone.

“textBox.setCommandListener(this);”

A aplicação fornece o TextBox  com a instância de HelloWorld como o CommandListener, para receber eventos de alto nível da implementação. Qualquer evento desse tipo que ocorrer quando esse TextBox estiver sendo exibido, será notificado ao HelloWorld.

“Display.getDisplay(this).setCurrent(textBox);”

Agora que o TextBox foi criado, pode ser mostrado na tela do dispositivo. Nessa linha, a tela atual é configurada para ser a recem criado TextBox. Quando HelloWorld for iniciado, não existe ainda nenhum Displayable.

Um MIDlet pode pegar uma referência para o gerenciador da tela (abstraido como Display) e dispositivos de entrada do sistema, chamando o metódo Display.getDisplat(). Essa linha garante que o gerenciador da tela fará que o TextBox seja visivel e ativa a interação com o ousuário.

“public void commandAction(Command aCommand, Displayable aScreen)”

Esse metódo é a implementação da interface CommandListener que o MIDlet declara-se como uma implementação dele. Quando a implementação indica que o comando iExitCommand ocorreu, esse metódo é chamado.

“notifyDestroyed();”

O MIDlet notifica o AMS que entrou no modo Destruido. Note que em um exemplo mais complexo o MIDlet precisa executar a mesma limpeza e liberação de recursos que teria feito se MIDlet.destroyApp() tivesse  sido chamado pelo AMS.