JAVA2ME Interface

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

Clique para editar o estilo do título mestre
Clique para editar o estilo do subtítulo mestre
*
*
*
Java 2 ME
Interface
Prof. Afonso Ferreira Miguel, MSc
*
*
*
Java Micro Edition (J2ME)
Visão Geral:
Plataforma de desenvolvimento voltada para 2 tipos de dispositivos:
High-end consumer devices: 
CDC (Connected Device Configuration)
TV interativa, Videofones, dispositivos wireless,...
Grande variedade de interfaces com usuário
Memória a partir de 2 a 4 Mb.
Conexão persistente e de banda larga, normalmente TCP/IP
*
*
*
Java Micro Edition (J2ME)
Visão Geral:
Plataforma de desenvolvimento voltada para 2 tipos de dispositivos:
Low-end consumer devices: 
CLDC (Connected Limited Device Configuration)
Telefones Celulares, pagers bi-direcionais, PDAs,...
Memória a partir de 128 kb
Conexão lenta, intermitente e normalmente não baseada em TCP/IP.
Utilizam baterias.
*
*
*
Java Micro Edition (J2ME)
Objetivos (CLDC):
Carga dinâmica de aplicações
Desenvolvimento por terceiros
Independência de padrões de rede
Compatibilidade com outros padrões wireless
*
*
*
Java Micro Edition (J2ME)
Dispositivos alvo (CLDC):
pelo menos 160kb de memória disponível para Java
Processador entre 8 e 32 MHz, 16 ou 32 bit
Alimentado por bateria
Conectividade limitada (9600 bps ou menos)
Produção em alta escala
*
*
*
Java Micro Edition (J2ME)
Sistema Operacional
Configuration 
Profile(s)
Bibliotecas
JVM
{
*
*
*
Java Micro Edition (J2ME)
K Virtual Machine (KVM):
Pequena: núcleo a partir de 60kb
Altamente portável
modular e customizável
Desenvolvida para dispositivos a partir de 128kb de memória
*
*
*
Java Micro Edition (J2ME)
MIDlets
Unidade básica de execução do MIDP
Derivada de javax.microedition.MIDlet
3 métodos abstratos
startApp, pauseApp, destroyApp
*
*
*
Java Micro Edition (J2ME)
startApp()
Invocado quando da inicialização e reinicialização do Midlet
Deve obter os recursos necessários para execução (timers, conexões de rede)
É invocado mais do que uma vez
Pode falhar de 2 maneiras:
transient: a falha é temporária (ex. falha de conexão). O MIDlet pode avisar ao sistema para reiniciá-lo mais tarde lançando uma MIDletStateChangeException
non-transient: Erro fatal. Pode ser tratado ou lançado para o sistema que irá invocar o método destroyApp
*
*
*
Java Micro Edition (J2ME)
pauseApp()
Invocado toda a vez que o MIDlet é “colocado em pausa”
Quando receber a notificação, o MIDlet deve liberar tantos recursos quanto possível e permanecer em dormência.
Não é obrigatório, porém o sistema pode optar por terminar a execução de MIDlets que não atenderem a requisição.
*
*
*
Java Micro Edition (J2ME)
destroyApp(boolean)
Invocado quando o MIDlet está para ser destruído.
O parâmetro indica se a destruição é incondicional. Caso negativo, o MIDlet pode requisitar uma “stay of execution” lançando uma exceção MIDletStateChangeException
*
*
*
Java Micro Edition (J2ME)
Transição de Estados
Paused
Active
Destroyed
new HelloWorld()
startApp
pauseApp
destroyApp
destroyApp
resumeRequest
notifyPaused
notifyDestroyed
notifyDestroyed
Métodos do MIDlet para forçar mudança de estado
*
*
*
Java Micro Edition (J2ME)
Estrutura da UI
Cada MIDlet possui um Display, onde uma instância de Displayable é mostrada de cada vez
A aplicação seta o Displayable corrente de acordo com a evolução do sistema e as interações com o usuário
Dois tipos de Displayable
Canvas: baixo nível
Screen: alto-nível, encapsulamento de componentes de UI 
*
*
*
Java Micro Edition (J2ME)
Display
Displayable
Screen
Canvas
Alert
List
TextBox
Form
Item
StringItem
ImageItem
TextField
DateField
Gauge
ChoiceGroup
0..1
0..n
Command
*
*
*
Java Micro Edition (J2ME)
Estrutura básica de um MIDlet
*
*
*
1ª aplicação... ... Hello World
Criar projeto com botão New Project...
Pressionar OK
Passo 1: Criando projeto no J2ME Wireless Toolkit 
*
*
*
1ª aplicação... ... Hello World
Criar um Empty Project no diretório c:\Wtk104\apps\ com o mesmo nome do projeto criado no J2ME Wireless Toolkit (MeuTeste);
Criar um Java File chamado HelloWorld.java no diretório c:\Wtk104\apps\MeuTeste\src\
Passo 2: Criando projeto no JCreator
*
*
*
1ª aplicação... ... Hello World
Entrar com o código a seguir:
Salvar
Passo 3: código Java
import javax.microedition.midlet.MIDlet;
import javax.microedition.lcdui.*;
public class HelloWorld extends MIDlet implements CommandListener
{
 private Form form;
 public HelloWorld()
 {
 form = new Form("Isto é um teste");
 form.append("Olá Mundo!");
 form.addCommand( new Command( "Sair", Command.EXIT, 1 ) );
 form.setCommandListener( this );
 }
 public void startApp()
 {
 Display display = Display.getDisplay(this);
 display.setCurrent( form );
 }
 public void pauseApp()
 {
 }
 public void destroyApp(boolean unconditional)
 {
 form = null;
 }
 public void commandAction(Command c, Displayable d)
 {
 destroyApp(true);
 notifyDestroyed();
 }
}
*
*
*
1ª aplicação... ... Hello World
Passo 4: compilando e testando...
Voltar ao J2ME Wireless Toolkit compilar o projeto com o botão Build;
Selecionar o device a ser emulado (Motorola_i85s);
Executar através do botão Run;
Selecionar a aplicação e executá-la através do botão Launch.
*
*
*
Java Micro Edition (J2ME)
Display: é a interface de tela padrão. Para obtê-la, devemos evocá-la no construtor do MIDlet utilizando:
*
*
*
Java Micro Edition (J2ME)
TextBox: caixa de texto Displayable. Para ser exibida, deve ser:
 Definida em uma referência;
 Criada utilizando new e com os parâmetros adequados;
 Exibida conectando-se ao display padrão (no método start).
*
*
*
Java Micro Edition (J2ME)
Exercício 1: Crie um novo projeto chamado Midlet1 criando também uma caixa de texto. Compile (corrigindo os erros) e:
Verifique o aspecto desta caixa de texto e as formas de digitação nos diferentes tipos de aparelhos (iDEN, PALM, etc.);
Substitua o parâmetro constraints e verifique o resultado na digitação.
*
*
*
Java Micro Edition (J2ME)
List: lista que exibe várias opções.
Opções podem ser listadas no construtor ou utilizando o método append. A princípio, colocar null na lista de imagens.
*
*
*
Java Micro Edition (J2ME)
Exercício 2: modifique o projeto Midlet1 retirando o TextBox e adicionando o List. Compile (corrigindo os erros) e:
Verifique o aspecto da lista e as formas de seleção nos diferentes tipos de aparelhos (iDEN, PALM, etc.);
Teste as várias opções do parâmetro listType e verifique o resultado na seleção;
Modifique o código para utilizar o ouro construtor.
*
*
*
Java Micro Edition (J2ME)
List com Imagens:
As imagens são carregadas a partir do diretório src do projeto. Para criar uma imagem utiliza o método estático Image.createImage(“..."); 
*
*
*
Java Micro Edition (J2ME)
Exercício 3: modifique o projeto Midlet1 adicionando uma mesma imagem a cada opção da lista.
*
*
*
Java Micro Edition (J2ME)
Form:
Formulário é um Displayable que permite a adição de diferentes tipos de controles (chamados de Item).
Form
Item
StringItem
ImageItem
TextField
DateField
Gauge
ChoiceGroup
0..n
*
*
*
Java Micro Edition (J2ME)
Form: o processo de criação de um Form é semelhante ao TextBox e List.
*
*
*
Java Micro Edition (J2ME)
Form: uma vez criado o formulario, podemos adicionar os controles
TextField: campo de texto
*
*
*
Java Micro Edition (J2ME)
Exercício 4: modifique o projeto Midlet1 adicionando um formulário que solicite as informações Nome e Telefone. Teste-o nos vários Handsets.
*
*
*
Java Micro Edition (J2ME)
Form:
StringItem: string fixa.
*
*
*
Java Micro Edition (J2ME)
Exercício
6: modifique o formulário do item anterior adicionando o nome da empresa (“HAL INC”) no início.
*
*
*
Java Micro Edition (J2ME)
Form:
ChoiceGroup: lista com itens permitindo seleção simples e múltipla. Os itens podem ser listados no construtor ou com o comando append.
*
*
*
Java Micro Edition (J2ME)
Exercício 7: modifique o formulário do item anterior adicionando a seleção do estado civil (Solteiro/Casado). Os itens do controle ChoiceGroup devem ser adicionados com o comando append.
*
*
*
Java Micro Edition (J2ME)
Form:
DateField: seleção de Data e/ou Hora.
*
*
*
Java Micro Edition (J2ME)
Exercício 8: adicione o controle DateField no formulário anterior e verifique as opções DATE, DATE_TIME e TIME.
*
*
*
Java Micro Edition (J2ME)
Form:
Gauge: barra de progresso com ou sem seleção.
*
*
*
Java Micro Edition (J2ME)
Exercício 9: retire alguns itens do formulário anterior (para facilitar a visualização) e adicione um Gauge. Teste as opções interactive.
*
*
*
Java Micro Edition (J2ME)
Form:
ImageItem: imagem estática.
*
*
*
Java Micro Edition (J2ME)
Exercício 10: elimine todos os itens do formulário anterior (para facilitar a visualização) e um ImageField com uma figura e um StringField com o nome da imagem. Visualize em diferentes dispositivos.
*
*
*
Java Micro Edition (J2ME)
Command
Command são controles adicionados ao handset como hotkeys ou menus.
*
*
*
Java Micro Edition (J2ME)
Command
A adição do Command no projeto é feita em um objeto Displayable. Observe que o construtor possui 3 parâmetros.
*
*
*
Java Micro Edition (J2ME)
Exercício 11: modifique o MIDlet implementado adicionando 3 comandos com prioridades diferentes: “Sair”, “Novo”, “Excluir”. Localize cada um dos comandos nas telas apresentadas.
*
*
*
Java Micro Edition (J2ME)
Command
Tratando eventos do Command:
Para tratar os eventos dos botões, uma classe deve implementar a interface CommandListener.
*
*
*
Java Micro Edition (J2ME)
Command
Esta interface obriga a classe a implementar o método commandAction que é evocado quando algum comando do Displayable é solicitado.
*
*
*
Java Micro Edition (J2ME)
Command
A seguir, o Displayable precisa ser informado qual a classe que deverá receber os eventos. Para isto, é utilizado o método setCommandListener.
*
*
*
Java Micro Edition (J2ME)
Command
Por fim, visto que vários botões podem solicitar eventos, é necessário que a função commandAction identifique o comando e execute o código necessário.
Comandos necessários para encerrar o programa
*
*
*
Java Micro Edition (J2ME)
Exercício 12: modifique o MIDlet implementado adicionando a funcionalidade de “Sair”. Adicione também uma mensagem (System.out.println(“...”)) aos comandos “Novo” e “Excluir”. Teste nos Handset padrões e no PALM.
*
*
*
Java Micro Edition (J2ME)
Trocando a tela
Para navegar entre Displayables as telas podem ser comutadas utilizando o comando setCurrent().
*
*
*
Java Micro Edition (J2ME)
Exercício 13: modifique o MIDlet do exercício anterior adicionado um novo Displayable do tipo List. Neste último adicione um Command “Volta”. Adicione a funcionalidade necessária para que ao pressionar o botão “Novo”, o List seja exibido, e ao pressionar “Volta”, o formulário volte a ser exibido.
*
*
*
Java Micro Edition (J2ME)
List ou ChoiceGroup com múltiplas opções
*
*
*
Java Micro Edition (J2ME)
Exercício 14: modifique o MIDlet do exercício anterior para exibir com o comando System.out.println os valores de estado dos itens do List (modificá-lo para MULTIPLE).
*
*
*
Java Micro Edition (J2ME)
Exercício 15: implementar um programa que exiba uma lista de nomes (1). Ao pressionar um botão “Novo” uma tela solicitará um novo nome (2). Ao entrar com um novo nome, a lista original será atualizada(3). Estando um nome selecionado, ao pressionar o botão “Excluir”, este nome deverá desaparecer da lista.
(1)
(3)
(2)
*
*
*
J2ME
Display Gráfico
Display
Displayable
Screen
Canvas
Alert
List
TextBox
Form
Item
StringItem
ImageItem
TextField
DateField
Gauge
ChoiceGroup
0..1
0..n
Command
*
*
*
J2ME
Classe Canvas
Canvas é um Displayable do tipo abstract. Assim, não pode gerar uma instância direta.
*
*
*
J2ME
Classe Canvas
Para criar um objeto do tipo Canvas, é necessário criar uma subclasse, e instanciá-la. Observe os métodos abstratos da classe Canvas.
*
*
*
Java Micro Edition (J2ME)
Exercício 16: implementar um MIDlet que exiba uma classe derivada da Canvas. Modifique o código do método paint para o mostrado abaixo e veja o resultado:
*
*
*
J2ME
Canvas
Métodos chaves da classe Canvas:
paint: método evocado sempre que a Canvas precisa ser “pintada” na tela. Obs.: este método nunca deve ser evocado diretamente pelo programa do usuário;
repaint: método que pode ser evocado pelo programa do usuário solicitando que a tela seja “repintada”;
getHeight: retorna ao programa do usuário a altura da tela em pixels;
getWith: retorna ao programa do usuário a largura da tela em pixels;
hasPointerEvents: retorna true se o dispositivo aceita entradas do ponteiro (caneta, mouse, etc...);
hasPointerMotionEvents: retorna true se o dispositivo aceita entradas de movimento do ponteiro (drag);
*
*
*
J2ME
Graphics
Um objeto da classe Graphics é utilizado como parâmetro do método paint. Este objeto é a representação do display gráfico.
Para alterar o conteúdo da tela, devemos utilizar os métodos deste objeto:
*
*
*
J2ME
 Graphics
Métodos chaves da classe Graphics:
setColor: define a cor da caneta para pintar neste objeto;
drawLine: desenha uma linha simples;
drawRectangle: desenha um retângulo vazado;
drawRoundRect: desenha um retângulo vazado com cantos arredondados;
drawArc: desenha um arco ou círculo vazado;
fillRectangle: desenha um retângulo cheio;
fillRoundRect: desenha um retângulo cheio com cantos arredondados;
drawArc: desenha um arco ou círculo cheio;
drawImage: pinta uma imagem no Canvas;
*
*
*
J2ME
 Graphics
Métodos para texto da classe Graphics:
setFont: define a fonte para escrever textos;
drawChar , drawChars: escreve um ou mais caracteres na tela. Obs.: verificar os parâmetros de âncora (anchor);
drawString , drawSubstring: escreve uma string na tela. Obs.: verificar os parâmetros de âncora (anchor);
*
*
*
J2ME
 Graphics
“ Clip: área que poderá ser afetada pelos métodos de desenho. Desenhos fora desta área não aparecerão.”
 
Métodos para clipping e mudança de referência da classe Graphics:
setClip: define uma nova área para clipping;
clipRect: redefine a área de clipping para a intersecção da área atual e um retângulo;
translate: redefine uma posição de origem (0,0). Todos os métodos para desenho serão a partir desta nova origem.
*
*
*
Java Micro Edition (J2ME)
Exercício 17: implementar um MIDlet que exiba uma “cara sorridente” com olhos, nariz e boca, que ocupe a tela inteira, independente do dispositivo. Adicione também um Command para encerrar o MIDlet.
*
*
*
J2ME
 Canvas
Eventos: vários métodos relativos a eventos são definidos na classe Canvas:
 
keyPressed: chamado quando uma tecla é pressionada;
keyReleased: chamado quando uma tecla é solta;
pointerPressed: chamado quando o ponteiro (mouse, caneta) é pressionado em uma posição da tela;
pointerDragged: chamado quando o ponteiro (mouse, caneta) é arrastado. É chamado a cada nova posição;
pointerReleaser: chamado quando o ponteiro (mouse, caneta) é solto;
*
*
*
Java Micro Edition (J2ME)
Exercício 18: implementar um MIDlet que exiba uma bola no local onde a tela do PALM for pressionada. Observe que este programa não funcionará com outros dispositivos sem tela sensível.
*
*
*
J2ME
 Threads
Assim como em C, Threads são
muito fáceis de implementar e podem ser aplicadas em diversas áreas. Uma muito comum, é a animação.
Para a construção de threads, temos duas opções:
Criar uma subclasse da classe Thread;
Adicionar a interface Runnable a uma classe já existente.
*
*
*
J2ME
 Threads
Criar uma Thread a partir de uma subclasse da classe Thread;
Para disparar a subclasse como uma Thread, basta:
*
*
*
J2ME
 Threads
Criar uma Thread a partir de uma classe que implementa Runnable;
Para disparar a subclasse como uma Thread, basta:
*
*
*
J2ME
 Threads
Observações com relação a Thread:
A Thread será encerrada ao encerrar o método run(). Laços de repetição podem ser utilizados para que a Thread seja executada por um longo tempo;
Para suspender a execução da Thread por algum tempo, utilize o método estático Thread.spleep();
*
*
*
Java Micro Edition (J2ME)
Exercício 19: modificar a classe Canvas para que implemente Runnable. No método run(), implemente um laço repetitivo que imprima uma mensagem através do System.out.println. Faça este laço ser repetido a cada 1s (utilize Thread.sleep(1000) ).
*
*
*
Java Micro Edition (J2ME)
Exercício 20: modificar a classe do exercício 19 para que a bola se mova diagonalmente cada 10ms. Após visualizar a bola em movimento, modifique o código para a bola ficar rebatendo nas bordas.
*
*
*
J2ME
 Threads
Efeito de cintilação:
Aplicações que exigem animação geralmente executam o laço repetitivo:
Desenha;
Apaga;
Redesenha;
Apaga;
...
Porém, o tempo entre apagar e redesenhar muitas vezes provoca um cintilar (pisca-pisca) para o usuário, reduzindo o efeito de animação.
*
*
*
Java Micro Edition (J2ME)
Exercício 21: modificar o exemplo do exercício 20 para aparecer uma bola com 80 pixels de diâmetro. Observe que a bola algumas vezes parece não ser desenhada corretamente.
*
*
*
J2ME
 Threads
Duplo buffer: para minimizar os efeitos da cintilação, o processo de animação pode ser modificado para:
Desenha;
Sobrescreve;
Redesenha;
Sobrescreve;
...
Com isto, a tela nunca será apagada, evitando o efeito pisca-pisca.
*
*
*
J2ME
 Threads
Image
drawImage(...)
buffer
Para evitar a cintilação, primeiramente devemos desenhar em uma imagem previamente criada, para depois sobrescrevê-la no display gráfico.
*
*
*
Java Micro Edition (J2ME)
Exercício 22: modificar o exemplo do exercício 21 para que o desenho seja realizado em um buffer (objeto) do tipo Image, sendo atualizado na tela posteriormente.
Obs.: o apagamento agora deve ser feito no buffer.
*
*
*
J2ME
Teclas
Os eventos de teclado são baseados em códigos de qualquer tecla e em códigos de teclas dedicadas para jogos.
Para um Canvas tratar uma tecla, esta deve ser capturada pelos eventos:
keyPressed: chamado quando uma tecla é pressionada;
keyReleased: chamado quando uma tecla é solta.
E pode ser tratada pelo evento:
getGameAction: recupera o código de jogo de uma tecla.
*
*
*
J2ME
Teclas
Exercício 23: modificar o exemplo do exercício 22 para que uma mensagem seja exibida pelo System.out.println. Utilize o método getGameAction em um case e mostre uma mensagem customizada.
*
*
*
J2ME
Teclas
Exercício 24: diminua o tamanho da bola para 10 e adicione uma pequena raquete na parte inferior da tela que é movida pelo teclado.
Adicione uma variável “estado” que é inicializada com 0;
Adicione um botão (Command) que faça “estado”=1;
Modifique o código para que permita a movimentação da bola apenas quando “estado”=1;
Por fim, caso a bola não rebata na raquete, faça “estado”=0.
*
*
*
J2ME
Comunicação
J2ME tem permite que dispositivos com suporte a rede possam tirar proveito disso. Desta forma, classes foram criadas para fazer acesso UDP, TCP inclusive HTTP, etc.
O principal método para acesso é o Connector.open.
Este método permite criar conexões para diferentes protocolos seguindo o padrão:
 
*
*
*
J2ME
Comunicação
Comunicação em Rede
Datagrama:
Para melhor controle dos dados recebidos, é conveniente que processos de recepção sejam colocados em uma Thread separada. Isto permite que o programa principal possa receber dados enquanto está sendo executado.
*
*
*
J2ME
Comunicação
Datagrama
*
*
*
J2ME
Teclas
Exercício 25: modifique o exercício 24 para que a cada rebatida, um datagrama seja enviado para sua máquina(IP 127.0.0.1). Utilize a classe Comm criada pelo professor. Experimente mudar o IP para enviar o datagrama ao colega.
*
*
*
J2ME
Comunicação
Comunicação em Rede
Protocolo HTTP
Utilizando uma requisição GET:
HttpConnection c = (HttpConnection)Connector.open(“http://java.sun.com”);
int status = c.getResponseCode();
if(status != HttpConnection.HTTP_OK){
...
}
else {
InputStream is = c.openInuptStream();
...
is.close();
}
c.close();
*
*
*
J2ME
Comunicação
*
*
*
J2ME
Comunicação
Exemplo: HTTPTest
*
*
*
J2ME
Teclas
Exercício 26: modifique o sistema de controle do exercício 15 para que acesse a página http://10.26.134.100/bd.asp) que controla um banco de dados de nomes) para que todos os nomes sejam lidos e atualizados remotamente.
*
*
*
J2ME
Teclas
Avaliação: modificar o programa do exercício 24 para arquivar no banco de dados remoto (HTTP) o nome do jogador e o número de pontos.
*
*
*
Java Micro Edition (J2ME)
Persistência (Record Management System - RMS)
Fornece records e Record Stores
MIDP garante que um registro manterá seu recordId até que seja deletado.
Um recordId é gerado por um algoritmo de incremento unitário monotônico
*
*
*
Java Micro Edition (J2ME)
Acessando RecordStores
Identificados por um nome de até 32 caracteres Unicode, únicos por MIDlet suite
RecordStore.listRecordStores: lista os RecordStores da suite;
RecordStore.open(String, boolean): abre (ou cria) um RecordStore
RecordStore.close()
RecordStore.delete(String): remove um RecordStore
RecordStore.getNumRecords(): Número de registros no RS
RecordStore.getVersion(): Versão do RS, incrementada a cada operação de inserção, alteração ou exclusão de registro
RecordStore.getLastModified: Hora da última modificação
*
*
*
Java Micro Edition (J2ME)
Manipulando Registros
addRecord(byte[] data, int offset, int length)
deleteRecord(int Id)
getRecordSize(int Id)
getRecord(int id)
setRecord(int Id, byte[]data, int offset, int length)
Convertendo dados para array de bytes:
ByteArrayOutputStream
DataOutputStream
*
*
*
Java Micro Edition (J2ME)
Filtrando Registros
public interface RecordFilter
{
 public boolean matches(byte[] candidate);
}
Comparando Registros
public interface RecordComparator
{
 public int compare(byte[] b1, byte[] b2);
 public static final int EQUIVALENT;
 public static final int FOLLOWS;
 public static final int PRECEDES;
}
*
*
*
Java Micro Edition (J2ME)
Enumerando Registros:
RecordStore.enumerateRecords(RecordComparator,RecordFilter,boolean listen)
RecordEnumerator enum = rStore.enumerateRecords(null,null,false);
while(enum.hasNextElement()){
		byte []b = enum.nextRecord();
		...
}
Interface RecordListener:
public interface RecordListener{
	public void recordAdded(RecordStore rs, int rid);
	public void recordChanged(RecordStore rs, int rid);
	public void recordDeleted(RecordStore rs, int rid);
}