Sei sulla pagina 1di 15

JME

JME é uma tecnologia Java voltada para desenvolvimento em microdispositivos. No


curso de JME você aprenderá conceitos básicos sobre essa tecnologia, fará alguns
programas-exemplos e terá uma visão geral de desenvolvimento para celulares (não
incluindo a parte de jogos e conectividade). O curso não é um tutorial para se iniciar
em programação Java, portanto é necessário que o aluno já tenha um domínio
básico da linguagem. É necessário que o aluno acompanhe os exemplos, fazendo-
os, compilando e rodando.

Instalação
Temos à nossa disposição uma variedade de métodos de instalação do Java, podendo
variar dependendo da distribuição GNU/Linux utilizada.

É importante notar que diferentes métodos de instalação poderão prover versões


diferentes do software. Neste curso, por exemplo, utilizaremos a versão 1.6.0.

Para facilitar um pouco no início da programação JME usaremos uma IDE, o


NetBeans. Vale ressaltar que o uso de alguma IDE em específico ou até o não uso
de uma, fica a critério do próprio aluno. Porém, recomenda-se que o aluno siga a
nossa orientação.

Podemos diferenciar os métodos de instalação basicamente entre aqueles que


utilizam pacotes pré-compilados da própria distribuição ou aqueles que utilizam um
binário genérico para Linux, provido pela própria Sun Microsystems.

Para se programar em JME, precisa-se de três requisitos básicos:

• JDK (Java Development Kit);


• WTK (Wireless Toolkit) > especificamente para JME;
• Alguma IDE > isso fica a critério do programador.

No nosso curso faremos apenas o download e instalação do:

• NetBeans + JDK ( IDE integrada com o JDK);


• NetBeans Mobility Pack (anexo para programação para móveis no NetBeans,
incluindo o WTK).

Instalação através de pacote binário para ambientes Linux

O primeiro método que iremos abordar quanto à instalação do Java será o da instalação do
pacote binário provido pela Sun. Para atingir sucesso por esse método de instalação
devemos saber como obter esse pacote e instalá-lo, além de adicionar entradas
apropriadas nos arquivos de configuração do sistema.

O pacote binário do NetBeans+JDK pode ser obtido a partir do site da Sun, neste link. Esta
versão é o Netbeans 5.5.1 com o JDK 6. Deve-se então marcar a caixa "Accept" e clicar no
segundo link (se for realmente para Linux) para download do arquivo. Só para conferir, o
nome do arquivo deve ser "jdk-6u1-nb-5_5_1-linux-ml.bin"

Pronto, agora o pacote está sendo baixado. Após obtido o pacote você deverá executá-lo.
Mas antes, certifique-se de que você esteja logado no sistema como Superusuario(root).
Para tal, deve-se digitar o comando em um terminal:

$ su

Caso ele não esteja executável, pode ser necessário dar permissões de execução ao
arquivo utilizando o comando dentro do diretório onde ele estiver:

# chmod +x jdk-6u1-nb-5_5_1-linux-ml.bin

Feito isso, execute o arquivo com o comando:

# ./jdk-6u1-nb-5_5_1-linux-ml.bin

Se tudo for seguido como recomendado, o NetBeans e o JDK deverão ser instalados
automaticamente dentro do diretório opt , assim como mostra a figura:
Pronto, instalamos já a IDE NetBeans junto com o JDK.
Agora precisaremos instalar o Mobility Pack do NetBeans, fazendo o download dele neste
link. O arquivo se chama "netbeans_mobility-5_5_1-linux.bin".
Pronto, agora basta fazer o mesmo procedimento que foi feito na instalação do NetBeans;
Dar permissão ao arquivo e executá-lo.
Automaticamente será encontrado o diretório onde foi instalado o JDK, basta apenas
verificar.

Bem efetuadas as instalações, já temos o ambiente pronto para desenvolver em JME.


Breve História
Em 1991, engenheiros da Sun Microsystems tiveram a idéia de criar uma linguagem que
pudesse ser uma tecnologia inovadora e ímpar naquele momento. Eles acreditavam que o
futuro estava na convergência entre computadores e eletrodomésticos. Então, baseando-se
nessa crença foi criado o Oak(carvalho em inglês), linguagem altamente portável e voltada
para sistemas de baixa complexidade.

No entanto, o ideal pareceu estar muito distante da sua real aplicabilidade e, por
isso, o Oak encontrou sérias dificuldades mercadológicas, impedindo o "sonho" da
Sun Microsystems de se concretizar. Perseverante, a Sun prosseguiu com o projeto
voltando-se para uma nova tendência, um nicho de mercado emergente e até então
desconhecido, a Internet. A partir dai juntamente com o "boom" desse novo meio de
comunicação é que os engenheiros da Sun encontraram o caminho certo para
desenvolvimento e utilização do Oak. Mas, por problemas de direitos autorais o Oak
passa a ser chamado de Java e, em 1995, o sonho da Sun se realiza. É lançada
oficialmente a linguagem Java, feita inicialmente para se disseminar pela Internet,
por meios de programas (applets) que se executavam dentro dos browsers.

Em 1999, a Sun Microsystems lança o JME ( Java Mobility Edition), retomando um


pouco da idéia original do Oak de se programar para dispositivos móveis e
softwares embarcados. Desde o seu lançamento, centenas de corporações na área
de dispositivos móveis aderiram a essa tecnologia. Mais tarde, ela ganha a versão
2.0, o que a levou a ser conhecida como J2ME.

É importante ressaltar que, a partir de 2006, passou-se a utilizar uma nova


nomenclatura para essas plataformas. O número 2 foi retirado da sigla que a
representa passando a ser somente JME.

Introdução

Plataformas de Desenvolvimento para Dispositivos Móveis:

Windows Mobile - SO(SistemaOperacional) para dispositivos móveis da


Microsoft;

SymbianOS - SO otimizado para terminais móveis;

Brew - Voltado para o desenvolvimento de aplicativos apenas para celulares


CDMA;

ExEn - Voltado para o desenvolvimento de jogos, visando principalmente o


mercado europeu;

Mophun - Outra linguagem voltada para o desenvolvimento de jogos para


celulares;
JME - Voltado para odesenvolvimento de aplicativos para dispositivos móveis.

Nesse curso abordaremos a Plataforma JME.

O Java Micro Edition é usado para dispositivos muito limitados. Ou seja, pouca
capacidade de processamento, pequena fonte de energia e pouca memória,
problemas que hoje em dia estão sendo contornados pelo uso de memórias
externas. Essa plataforma foi feita para se conseguir rodar aplicações assim como
acontece na JSE, só que em micro dispositivos. Alguns até consideram que a JME é
nada mais do que um compacto da JSE, o que não deixa de ser verdade até certo
ponto.

Para construção do JME foi preciso fazer uma grande modificação na JSE,
consistindo basicamente de remoções de certas propriedades e adaptação de
outras. Tudo isso com o propósito de melhor se adequar à arquitetura dos micro
dispositivos. A JVM (Java Virtual Machine), por exemplo, foi adaptada para se criar
a JKVM (Java Kilo Virtual Machine), sendo a primeira na ordem de megas e a
segunda na ordem de kilos, justamente por causa da memória reduzida.

Arquitetura JME

Configurações (CDC/CLDC)

JME oferece duas "configurações": a CDC (Connect Device Configuration) e a CLDC


(Connect Limited Device Configuration), que se caracterizam de acordo com o tipo de
dispositivo.

Connect Device Configuration - CDC


Para dispositivos maiores em termos de memória, processamento e energia, geralmente
ligados por fios.
Exemplos: Televisores interativos, set-top box (para tvs digitais), sistemas de navegação de
carro...

Connect Limited Device Configuration - CLDC:


A tecnologia CLDC é um subconjunto do CDC. Foi feito para dispositivos mais limitados,
com grande ou total portabilidade. Nosso foco se encontrará aqui, visto que é aqui que se
enquadram certos dispositivos tão corriqueiros em nosso dia-a-dia.

Exemplos: celulares com tecnologia JAVA, smartphones, pagers, PDAs.

Perfis

Os perfis nos fornecem um conjunto de APIs combinadas para formar um ambiente


específico. Junto com as configurações proverão acesso a propriedades específicas dos
dispositivos. Abaixo, serão citados alguns perfis.
• Mobile Information Device Profile(MIDP) - Perfil de máximo nível na configuração
CLDC, feito para celulares e PDAs.
• Foundation Profile(FP) - É o perfil de nível mais baixo dentre os outros perfis de
CDC.
• Personal Profile(PP) - Perfil CDC para suportes à applets e interface gráfica AWT.
• Personal Basis Profile(PBP) - Divisão do PP que suporta um nível básico de
interface gráfica.

Neste curso abordaremos o MIDP, que se divide em sua antiga versão MIDP1.0 e a sua
mais nova MIDP2.0.

MIDP
Falaremos agora um pouco mais do perfil MIDP.
Ele é um ambiente de desenvolvimento para MIDs e oferece muita eficiência e liberdade.
Algumas características:
-128kB de memória não-volátil para JAVA;
-32KB de memória volátil para tempo de execução;
-8KB de memória não-volátil de para armazenamento de dados;
-uma tela com o mínimo de 96x54 pixels;
-Capacidade de entrada de dados: teclado, tela touch-screen, etc.

MIDP 1.0 E MIDP 2.0:

O perfil MIDP 2.0 é uma versão mais nova do perfil MIDP. Ele apresenta funcionalidades
que o MIDP 1.0 não apresenta.
As funcionalidades originadas na versão 2.0 mais marcantes são classes próprias para jogo
(GameAPI), comunicação de dados por https (mais segura), manipulação de
sons(MediaAPI) e segurança no geral.
Com a versão 1.0 não se pode fazer coisas como:
-Pontos Flutuantes: double e float;
-Apesar de existir o Garbage Collector, não se pode utilizar o método automático;
-MultiThreading não possui os métodos pause(), resume(), stop() e interrupt();
-Uso de métodos nativos;
-Em java.lang.Object não se tem o método finallize();

Entre outros.

MIDlets
MIDlets são aplicativos JME desenvolvidos dentro do perfil MIDP. Tem como principal
característica a portabilidade, pode-se rodar em qualquer ambiente desde que esse tenha
suporte à JME-MIDP.
Ciclo de vida do MIDlet

Os MIDlets possuem um ciclo de vida. Um MIDLet pode estar em 3 estados: ativado,


pausado e terminado (ou destruído).

• public voidstartApp(): é o método que será chamado no início de execução do


aplicativo. Ele será chamado logo depois do construtor da classe. Geralmente aqui é
definido o componente que será mostrado na tela.

• public voidpauseApp(): é o método que será chamado quando houver uma


interrupção na execução do aplicativo por parte do sistema operacional do aparelho,
por exemplo, o recebimento de uma ligação, mensagem de bateria fraca, etc. Aqui
deve-se criar um meio de congelar(pause) a aplicação para que ela possa ser
recuperada corretamente depois da interrupção.

• public voiddestroyApp(boolean b): é o método chamado quando o aplicativo é


fechado. Aqui pode-se colocar códigos para persistir alguma informação que você
queira recuperar nas próximas vezes que abrir o aplicativo.

É importante lembrar que esses três métodos devem estar presentes em qualquer classe
que herde de MIDlet. Porém, não precisam conter código dentro deles, a não ser o
startApp, que é onde chamamos um componente Displayable para a tela.

Iniciando no NetBeans
Iremos nesta lição, programar, compilar e rodar o nosso primeiro MIDlet. Antes, iremos ver
algumas coisas básicas do NetBeans como: criar, compilar e rodar um programa.

O primeiro passo é criar um novo projeto. Acompanhe a figura a seguir:

Selecione "Mobile Application" dentro da categoria "Mobile" e clique em "Próximo".

Agora, escolha o nome do projeto. No exemplo foi usado "Primeiro Programa". Desmarque
a caixa "Create Hello MIDlet", assim como a figura mostra:
Clique em "Finalizar".

Pronto, nosso projeto está criado. O segundo passo é criar um novo arquivo. Acompanhe a
figura abaixo:
Selecione "MIDlet" dentro da categoria "MIDP". Clique em "próximo".

Pronto! Já temos um projeto criado e um arquivo. Agora é só começar nosso programa.

Primeiro Programa

Faremos um midlet simples, o clássico "HelloWorld". É bom se iniciar com o


HelloWorld para mostrar que JME não tem nenhum mistério. Bem, primeiramente
vamos ver o código, as explicações virão comentadas. Examinem e façam o
programinha abaixo.

_________________________________________________________________________
_________________________

import javax.microedition.midlet.*; //importando a biblioteca midlet e


lcdui
import javax.microedition.lcdui.*;

//aqui a classe concreta HelloWorld estende à classe abstrata MIDlet


public class HelloWorld extends MIDlet {
//criando um objeto da classe Display, ele representará a tela do celular

private Display display;

//criando o StringItem que vai receber a nossa string

private StringItem hellostring;

//criando um Form

private Form formularioPrincipal;

public HelloWorld() //metodo construtor

display=Display.getDisplay(this); //associa o objeto display à tela do


celular

formularioPrincipal = new Form("Helo"); //adiciona um título ao nosso form

//passamos a string para o objeto hellostring. O primeiro parâmetro é o


título que o hellostring terá

hellostring = new StringItem("","Hello World!");

//faz-se um append do hellostring com formularioPrincipal

formularioPrincipal.append(hellostring); //assim o StringItem ficará


"colado" no form.

/*
* abaixo temos as 3 classes que todo MIDlet deve ter
*/
public void startApp() {

display.setCurrent(formularioPrincipal); // carrega o formularioPrincipal

public void pauseApp() {


}

public void destroyApp(boolean unconditional) {


}
}
//fim MIDlet ----------------
_________________________________________________________________________
_________________________
Observem que os métodos startApp ,pauseApp e destroyApp sempre devem constar nos
MIDlets, mesmo que o pauseApp e o destroyApp estejam sem conteúdo.

Pronto, aí está o Hello World, agora compilem.

E está pronto o nosso programa . Agora basta compilar e rodar, assim como mostra a
figura:

Nosso programa então abrirá no emulador do WTK (Wireless Toolkit) e deverá ser mostrado
como na figura:
Obs: Esse emulador de celular mostrado na figura é o emulador que vem com o WTK. O
nosso será um pouco diferente, pois usaremos o emulador do Mobility Pack do NetBeans.
Não se preocupem, a diferença é apenas visual.

Threads

Veremos agora um RESUMO de threads, para que possamos usar na lição


seguinte.

Em Java, pode-se lançar múltiplas atividades dentro de um único processo. A isso


chamamos Threads ou MultiThreading. Um programa em execução é dito como
um processo. Um processo em adamento aloca diversos recursos como memória,
uso do processador e outros, sendo que o sistema operacional é o responsável por
esse controle. Já quem controla as várias threads dentro do programa é próprio
interpretador Java. Por isso o uso de threads proporciona um maior desempenho
em ambientes mulltiprocessados, simplifica a modelagem de algumas aplicações e
tem um custo menor de gerenciamento em relação aos processos.

Há duas maneiras de se implementar threads em Java, usando-se herança da


classe Thread ou implementando uma interface da classe Runnable.

Uma thread têm os seguintes estados:

-Criada: instância de Thread criada, mas segmento não iniciado;


-Executável: método start() chamado; está esperando instrução para ser
executado;
-Suspensa (espera/bloqueio): ativo, mas não está barrado para execução.
Pode tornar a ser executável. Espera por recurso ( I/O) ou causada pelo
código;
-Em Execução: thread sendo executada;
-Inativa: quando o método run() é concluído.

Principais Métodos:

run() - Executa as atividades da thread. Se este método finaliza, a thread


também o faz;
start() - Determina a execução da thread. Chama o método run() antes de
finalizar;
sleep(int x) - Coloca a thread para dormir por x milisegundos;
join() - Espera o término da thread para qual foi mandada a mensagem para
poder ser liberada;
yeld()- cede a vez para outro segmento;
interrupt() - Interrompe a execução da thread e cede a vez para outro
segmento;
interrupted() - Testa se a thread está ou não está interrompida.

Prioridades de Threads
Em Java, a prioridade é determinada como um valor inteiro de 1 à 10. A
prioridade 10 é a maior, a 1 é a menor e a 5 é a prioridade padrão. A thread
herda a prioridade da thread que acriou. Métodos:

void setPriority(int prioridade);


int getPriority();