Prof. Afonso Ferreira Miguel, MSc

Prof. Afonso Ferreira Miguel, MSc
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

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.

Objetivos (CLDC): Carga dinâmica de aplicações Desenvolvimento por terceiros Independência de padrões de rede Compatibilidade com outros padrões wireless

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

Profile(s) Configuration { Bibliotecas JVM Sistema Operacional

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

MIDlets Unidade básica de execução do MIDP Derivada de javax.microedition.MIDlet 3 métodos abstratos startApp, pauseApp, destroyApp

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

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.

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

Transição de Estados new HelloWorld() notifyPaused pauseApp Paused Active startApp resumeRequest destroyApp destroyApp notifyDestroyed notifyDestroyed Destroyed Métodos do MIDlet para forçar mudança de estado

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

Alert Display StringItem List Screen ImageItem TextBox 0..1 TextField Displayable Form DateField Canvas 0..n Gauge Item ChoiceGroup Command

Estrutura básica de um MIDlet

1ª aplicação... ... Hello World
Passo 1: Criando projeto no J2ME Wireless Toolkit Criar projeto com botão New Project... Pressionar OK

Passo 2: Criando projeto no JCreator 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\

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(); Passo 3: código Java Entrar com o código a seguir: Salvar

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.

Display: é a interface de tela padrão. Para obtê-la, devemos evocá-la no construtor do MIDlet utilizando:

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).

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.

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.

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.

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(“...");

Exercício 3: modifique o projeto Midlet1 adicionando uma mesma imagem a cada opção da lista.

Form: Formulário é um Displayable que permite a adição de diferentes tipos de controles (chamados de Item). StringItem ImageItem TextField Form DateField 0..n Gauge Item ChoiceGroup

Form: o processo de criação de um Form é semelhante ao TextBox e List.

Form: uma vez criado o formulario, podemos adicionar os controles TextField: campo de texto

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.

Form: StringItem: string fixa.

Exercício 6: modifique o formulário do item anterior adicionando o nome da empresa (“HAL INC”) no início.

Form: ChoiceGroup: lista com itens permitindo seleção simples e múltipla. Os itens podem ser listados no construtor ou com o comando append.

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.

Form: DateField: seleção de Data e/ou Hora.

Exercício 8: adicione o controle DateField no formulário anterior e verifique as opções DATE, DATE_TIME e TIME.

Form: Gauge: barra de progresso com ou sem seleção.

Exercício 9: retire alguns itens do formulário anterior (para facilitar a visualização) e adicione um Gauge. Teste as opções interactive.

Form: ImageItem: imagem estática.

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.

Command Command são controles adicionados ao handset como hotkeys ou menus.

Command A adição do Command no projeto é feita em um objeto Displayable. Observe que o construtor possui 3 parâmetros.

Exercício 11: modifique o MIDlet implementado adicionando 3 comandos com prioridades diferentes: “Sair”, “Novo”, “Excluir”. Localize cada um dos comandos nas telas apresentadas.

Command Tratando eventos do Command: Para tratar os eventos dos botões, uma classe deve implementar a interface CommandListener.

Command Esta interface obriga a classe a implementar o método commandAction que é evocado quando algum comando do Displayable é solicitado.

Command A seguir, o Displayable precisa ser informado qual a classe que deverá receber os eventos. Para isto, é utilizado o método setCommandListener.

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

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.

Trocando a tela Para navegar entre Displayables as telas podem ser comutadas utilizando o comando setCurrent().

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.

List ou ChoiceGroup com múltiplas opções CAST

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).

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) (2) (3)

J2ME Display Gráfico Alert Display StringItem List Screen ImageItem
TextBox 0..1 TextField Displayable Form DateField Canvas 0..n Gauge Item ChoiceGroup 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.

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.

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;

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();

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) ).

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; ... 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.

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; ... Com isto, a tela nunca será apagada, evitando o efeito pisca-pisca.

J2ME Threads buffer drawImage(...) Image Para evitar a cintilação, primeiramente devemos desenhar em uma imagem previamente criada, para depois sobrescrevê-la no display gráfico.

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 ). 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(“ 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 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.

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 Record 1 Record 17 Record 10 Record 2 RecordStore

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

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

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;

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);

Prof. Afonso Ferreira Miguel, MSc

Apresentações semelhantes

Apresentação em tema: "Prof. Afonso Ferreira Miguel, MSc"— Transcrição da apresentação:

Apresentações semelhantes

Sobre projeto

Feedback

Login

Autorizar-se através da rede social:

Prof. Afonso Ferreira Miguel, MSc

Apresentações semelhantes

Apresentação em tema: "Prof. Afonso Ferreira Miguel, MSc"— Transcrição da apresentação:

Apresentações semelhantes

Sobre projeto

Feedback