J2ME Desenvolvimento GUI

J2ME
J2ME
Desenvolvimento

Leonardo Melo Santos
leonardomelosantos@gmail.com

J2ME
Tópicos
•
•
•
Arquitetura e visão geral
JAD e JAR
MIDlet
• Ciclo de vida e estrutura de um MIDlet
• Interface gráfica – High-level API
– Alert
– TextBox
– List
– Form
• TextField, DateField, StringItem e ImageItem
• ChoiceGroup
• Gauge

J2ME
Arquitetura e visão geral
MIDlet
1 1

Display
1 *

Displayable
1 *

Command

Screen Canvas
high-level API’s low-level API’s

* 1

Item Form TextBox List Alert

ChoiceGroup DateField Gauge ImageItem TextField StringItem

J2ME
MIDlet
• Aplicativo Java para mobiles (J2ME + MIDP)
– Ponto de início/entrada de um aplicativo J2ME
instalado no dispositivo.
– Trata-se de uma classe Java que deve herdar de
javax.microedition.midlet.MIDlet, e deve
implemenetar três métodos abstratos: startApp(),
pauseApp() e destroyApp(boolean);
– Possui um conjunto de telas, e cada tela possui um
conjunto de comandos.
– Precisa saber quem é o “ouvinte” dos comandos
acionados nas telas (um Listener).
– Parecido com os Applets.
– Apenas imagens PNG.

J2ME
Ciclo de vida de um MIDlet

construtor
•Ativo – Onde é feita a
Aquisição de recursos
inicializando a execução.

•Pausado – Liberação de
recursos em um modo de
Pausado
Pausado
espera, ou seja, pausado
utilizado ao atender
telefone, receber SMS
dentre outra aplicação.
)
p(

()

de
Ap

pp

st
tA
se

oyr
•Destruído – Liberação de
ar
u

A
pa

st

todos os recursos.

pp
destroyApp() ()
Ativo
Ativo Destruído
Destruído

J2ME
Ciclo de vida de um MIDlet
AMS - Application Manegement Software
Software pré-instalado em dispositivos MIDP que funciona como um ambiente
operacional, e é responsável pela chamada dos métodos, startApp(), pauseApp() e
destroyApp(), conforme o ciclo de vida visto acima.
AMS MIDlet
O construtor padrão do MIDLet
Cria uma nova instancia do MIDLet. (que está no estado pausado) é
chamado

Vai decidir o tempo apropriado para que o MIDLet seja executado. O MIDLet carrega todos os
Para isso ele faz a chamada do método startApp para que o estado recursos necessários para que
do aplicativo seja mudado para ativo. ele seja executado.

Faz com que o MIDlet reduza significativamente a quantidade de
O MIDLet deixa de executar o
recursos da memória que ele está consumindo, de forma que o
serviço e escolhe alguns
AMS pode ser usado temporariamente através de outras funções
recursos mais necessários.
no dispositivo como um telefonema ou rodando outro MIDlet .
Se foi ordenado que seja
Recebe uma determinação de que o MIDlet não é mais necessário,
finalizado, o MIDlet salva estado
assim o MIDlet que é candidato a ser destruído chama o método
ou preferências de usuário e
para auto-destruição, destroyApp.
executa a limpeza.

J2ME
Estrutura de um MIDlet
Esqueleto básico
import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;

public class DespesasMidlet extends MIDlet {

protected void startApp() throws MIDletStateChangeException {

}

protected void pauseApp() {

}

protected void destroyApp(boolean incondicional) throws
MIDletStateChangeException
{
}

}

J2ME
Estrutura de um MIDlet
Adicionando o “ouvinte”
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Displayable;
import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;

public class DespesasMidlet extends MIDlet implements CommandListener {

protected void startApp() throws MIDletStateChangeException {
}

protected void pauseApp() {
}

protected void destroyApp(boolean arg0) throws MIDletStateChangeException {
}

public void commandAction(Command comando, Displayable componente) {
// Este método é executado sempre que um Command de um determinado
// Displayable é acionado. Cada Displayable precisa saber quem é a classe
// ouvinete. Neste caso, a classe ouvinete é this.
}
}

J2ME
Interface gráfica - High-level API

• Não permite desenhar na tela (como na Low-level
API, ou simplesmente Canvas);
• Definido pelo pacote javax.microedition.lcdui;
• A aparência muda de acordo com o dispositivo;
• Mostra um Displayable na tela por vez:
– Display.getDisplay(meuMidlet).setCurrent(meuDisplayable)
;

J2ME
Command

São botões que podem ser adicionados num Displayable.

Construtores
•Command(String rotulo, int tipoComando, int prioridade)
•Command(String rotuloCurto, String rotuloLongo,
int tipoComando, int prioridade)

Tipos de Command
•Command.BACK –
Volta para uma tela anterior.
•Command.CANCEL –
Sai da operação antes de iniciar algo.
•Command.EXIT –
Faz com que o MIDlet termine todas as operações.
•Command.HELP –
Solicitação de ajuda.
•Command.ITEM –
Utiliza algum comando referente ao item do
componente utilizado.
•Command.OK – Solicita a confirmação do usuário para uma operação.
•Command.SCREEN – Operação referente ao Display atual.
•Command.STOP – Parar um processo.

J2ME
Alert

Funciona como uma tela de aviso, com ou sem imagem.

Construtores
•Alert(String titulo)
•Alert(String titulo, String texto, Image imagem, AlertType tipoAlerta)

AlertType
•AlertType.ALARM – Para mostrar um alerta sobre algo.
•AlertType.CONFIRMATION – Para confirmação do usuário.
•AlertType.ERROR – Para mostrar uma mensagem de Erro.
•AlertType.INFO – Para mostrar alguma informação.
•AlertType.WARNING – Mensagem de perigo.

J2ME
Alert - Exemplo
1. import java.io.IOException;
2. import javax.microedition.lcdui.*;
3. import javax.microedition.midlet.*;
4.
5. public class MeuMidlet extends MIDlet implements CommandListener {
6.
7. private Alert meuAlert;
8. private Command cmdOK;
9.
10. protected void startApp() throws MIDletStateChangeException {
11. Image imagem = null; // Alert também aceita não possuir imagem
12. try {
13. imagem = Image.createImage("/carro.png"); // Pegando uma imagem
14. } catch (IOException e) {
15. e.printStackTrace(); // Não encontrou a imagem na raiz do projeto
16. }
17. cmdOK = new Command("OK", Command.SCREEN, 0); // Instanciando um comando
18. meuAlert = new Alert("Título do Alert", "Mensagem do Alert com imagem.",
19. imagem, AlertType.WARNING);
20. meuAlert.addCommand(cmdOK); // Adicionando o Command ao Displayable
21. meuAlert.setCommandListener(this); // Ouvinte é a própria classe
22. Display.getDisplay(this).setCurrent(meuAlert); // Mostrando o Alert na tela
23. }
24.
25. public void commandAction(Command comando, Displayable displayable) { }
26.
27. protected void destroyApp(boolean incondicional) throws MIDletStateChangeException { }
28.
29. protected void pauseApp() {}
30.
31. }

J2ME
TextBox

Tela que capta entrada de dados do usuário.

Construtor
•TextBox(String rotulo, String texto, int tamanhoMax, int constraints)

Constraints
•TextField.ANY
•TextField.EMAILADDR
•TextField.NUMERIC
•TextField.PHONENUMBER
•TextField.URL
•TextField.DECIMAL
•TextField.PASSWORD
•TextField.UNEDITABLE
•TextField.SENSITIVE
•TextField.NON_PREDICTIVE
•TextField.INITIAL_CAPS_WORD
•TextField.INITIAL_CAPS_SENTENCE

J2ME
TextBox – Exemplo
3.
5.
6. private TextBox meuTextBox;
7. private Command cmdOK;
8.
10. cmdOK = new Command("OK", Command.SCREEN, 0); // Instanciando um comando
11. meuTextBox = new TextBox("Apelido", "<apelido>", 8, TextField.ANY);
12. meuTextBox.addCommand(cmdOK); // Adicionando o Command ao Displayable
13. meuTextBox.setCommandListener(this); // Ouvinte é a própria classe
14. Display.getDisplay(this).setCurrent(meuTextBox); // Mostrando o TextBox
15. }
16.
18.
20.
22.
23. }

J2ME
List

Trata-se de uma tela com uma listagem. Existem três
tipos de lista, e cada uma delas opcionalmente podemos
inserir uma imagem por item.
Construtor
•List(String titulo, int tipoLista)
•List(String titulo, int tipoLista, String[] listaStringsIniciais,
Image[] listaImagensIniciais)

Tipos de lista
•List.IMPLICIT
•List.EXCLUSIVE
•List.MULTIPLE

J2ME
List – Exemplo usando Command
4.
6. private List minhaLista;
7.
9. Image imagem1 = null; Image imagem2 = null; Image imagem3 = null;
10.
11. try {
12. imagem1 = Image.createImage("/animal1.png");
15. } catch (IOException e) { }
16.
17. minhaLista = new List("Minha listagem", List.IMPLICIT); // List.EXCLUSIVE ou List.MULTIPLE
18. minhaLista.append("Item 1", imagem1);
19. minhaLista.append("Item 2", imagem2);
20. minhaLista.append("SAIR", imagem3);
21. minhaLista.setCommandListener(this); // Ouvinte é a própria classe
22. Display.getDisplay(this).setCurrent(minhaLista); // Mostrando o List na tela
23. }
24.
25. public void commandAction(Command comando, Displayable displayable) {
26. if ((displayable == minhaLista) && (comando == List.SELECT_COMMAND)) {
27. String elementoSelecionado = minhaLista.getString(minhaLista.getSelectedIndex());
28. if (elementoSelecionado.equals("SAIR")) {
29. notifyDestroyed(); // Quando selecionar a terceira e última opção, a aplicação finaliza
30. }
31. }
32. }
33.
35.
37. }

J2ME
Itens de um Form: TextField

Caixa de texto que comporta-se muito parecido com um
TextBox, porém só pode ser usado dentro de um Form.
Construtor
•TextField(String rotulo, String texto, int tamanhoMax, int constraints)

Constraints
•TextField.ANY
•TextField.EMAILADDR
•TextField.NUMERIC
•TextField.PHONENUMBER
•TextField.URL
•TextField.DECIMAL
•TextField.PASSWORD
•TextField.UNEDITABLE
•TextField.SENSITIVE
•TextField.NON_PREDICTIVE
•TextField.INITIAL_CAPS_WORD
•TextField.INITIAL_CAPS_SENTENCE

J2ME
Itens de um Form: StringItem

Mostra dentro do Form um texto simples,
comportado-se como um rótulos apenas.

Construtor
•StringItem(String rotulo, String texto)
•StringItem(String rotulo, String texto, int aparencia)

Aparência
•Item.PLAIN – Texto simples
•Item.HYPERLINK – Em formato de Hyperlink
•Item.BUTTON – Em foma de botão.

J2ME
Itens de um Form: ImageItem

Mostra uma imagem dentro de um formulário.
Construtor
•ImageItem(String rotulo, Image imagem, int layout, String texto)
•ImageItem(String rotulo, Image imagem, int layout, String texto,
int aparencia)
Layout
•Item.LAYOUT_CENTER
•Item.LAYOUT_DEFAULT
•Item.LAYOUT_LEFT
•Item.LAYOUT_NEWLINE_AFTER
•Item.LAYOUT_NEWLINE_BEFORE
•Item.LAYOUT_RIGHT.

Aparência
•Item.PLAIN
•Item.HYPERLINK
•Item.BUTTON

J2ME
Itens de um Form: DateField

Mostra dentro do Form um campo para inserir data e/ou hora.
Permite consultar o calendário nativo do dispositivo.

Construtor
•DateField(String rotulo, int modoExibicao)
•DateField(String rotulo, int modoExibicao, TimeZone timeZone)

Modo de exibição
•DateField.DATE – Mostra apenas a data.
•DateField.TIME – Mostra apenas a hora.
•DateField.DATE_TIME – Mostra a data e a hora.

J2ME
TextField, StringItem, ImageItem e Date – Exemplo
4.
6. private Form meuForm;
7. private ImageItem imageItem;
8. private DateField campoData;
9. private TextField campoTexto;
10. private StringItem stringItem;
11.
13. meuForm = new Form("Meu Formulário");
14. Image imagem = null;
15. try {
16. imagem = Image.createImage("/animal2.png");
17. } catch (IOException e) { }
18. stringItem = new StringItem("Rótulo StringItem: ", "Valor do StringItem");
19. imageItem = new ImageItem("Imagem: ", imagem, Item.LAYOUT_DEFAULT, "Texto da imagem");
20. campoData = new DateField("Data: ", DateField.DATE);
21. campoTexto = new TextField("Seu nome: ", "", 20, TextField.ANY);
22. meuForm.append(stringItem); // Adicionando o StringItem ao formulário
23. meuForm.append(imageItem); // Adicionando o ImageItem ao formulário
24. meuForm.append(campoData); // Adicionando o DateField ao formulário
25. meuForm.append(campoTexto); // Adicionando o TextField ao formulário
26. meuForm.setCommandListener(this); // Ouvinte é a própria classe
27. Display.getDisplay(this).setCurrent(meuForm); // Mostrando o Form na tela
28. }
29.
31.
33.
35. }

J2ME
Itens de um Form: ChoiceGroup

Lista de escolha múltipla ou exclusiva. Também permite que
cada elemento do grupo possua uma imagem.

Construtor
•ChoiceGroup(String rotulo, int tipoChoiceGroup)
•ChoiceGroup(String rotulo, int tipoChoiceGroup,
String[] listaDePalavras, Image[] listaDeImagens)

Tipo de ChoiceGroup
•Choice.EXCLUSIVE – Escolha exclusiva, não notifica o listener
que este item foi selecionado.
•Choice.MULTIPLE – Escolha múltipla, não notifica o listener que
este(s) item(ns) foi(ram) selecionado(s).
•Choice.POPUP – Escolha exclusive, mostra um item de cada vez.

J2ME
ChoiceGroup – Exemplo
3.
6. private ChoiceGroup grupoEscolhaEclusivo, grupoEscolhaMultiplo, grupoEscolhaPopup;
7.
9. grupoEscolhaEclusivo = new ChoiceGroup("Exclusivo", ChoiceGroup.EXCLUSIVE);
10. grupoEscolhaEclusivo.append("Primeiro", null);
11. grupoEscolhaEclusivo.append("Segundo", null);
12. grupoEscolhaEclusivo.append("Terceitos", null);
13. grupoEscolhaMultiplo = new ChoiceGroup("Multiplo", ChoiceGroup.MULTIPLE);
14. grupoEscolhaMultiplo.append("Primeiro", null);
15. grupoEscolhaMultiplo.append("Segundo", null);
16. grupoEscolhaMultiplo.append("Terceitos", null);
17. grupoEscolhaPopup = new ChoiceGroup("Popup", ChoiceGroup.POPUP);
18. grupoEscolhaPopup.append("Primeiro", null);
19. grupoEscolhaPopup.append("Segundo", null);
20. grupoEscolhaPopup.append("Terceitos", null);
22. meuForm.append(grupoEscolhaMultiplo);
23. meuForm.append(grupoEscolhaEclusivo);
24. meuForm.append(grupoEscolhaPopup);
27. }
28.
30.
32.
}

J2ME
Itens de um Form: Gauge

Trata-se de uma barra de progresso. Existem dois tipos: o interativo
onde o usuário pode alterá-lo e o não interativo, que tem o conteúdo
alterado pela aplicação. São parecidos com Sliders.

Construtor
•Gauge(String rotulo, boolean interativo, int valorMaximo,
int valorInicial)

J2ME
Gauge – Exemplo com Command
3.
6. private Gauge gaugeInterativo, gaugeNaoInterativo;
7. private Command cmdIncrementar, cmdDecrementar;
8.
10. cmdIncrementar = new Command("Incrementar", Command.SCREEN, 0);
11. cmdDecrementar = new Command("Decrementar", Command.SCREEN, 1);
12. gaugeNaoInterativo = new Gauge("Não interativo: ", false, 100, 10);
13. gaugeInterativo = new Gauge("Interativo: ", true, 100, 20);
15. meuForm.append(gaugeNaoInterativo); // Adicionando no fomulário o Gauge não-interativo
16. meuForm.append(gaugeInterativo); // Adicionando no fomulário o Gauge interativo
17. meuForm.addCommand(cmdIncrementar); // Adicionando o comando que incrementa o não-interatvo
18. meuForm.addCommand(cmdDecrementar); // Adicionando o comando que decrementa o não-interatvo
21. }
22.
23. public void commandAction(Command comando, Displayable displayable) {
24. if (displayable == meuForm) {
25. if (comando == cmdIncrementar) {
26. this.gaugeNaoInterativo.setValue(this.gaugeNaoInterativo.getValue() + 1);
27. } else if (comando == cmdDecrementar) {
28. this.gaugeNaoInterativo.setValue(this.gaugeNaoInterativo.getValue() - 1);
29. }
30. }
31. }
32.
34.
36.
37. }

J2ME Desenvolvimento GUI

Recommandé

Recommandé

Contenu connexe

En vedette

En vedette (20)

Similaire à J2ME Desenvolvimento GUI

Similaire à J2ME Desenvolvimento GUI (20)

Plus de Leonardo Melo Santos

Plus de Leonardo Melo Santos (19)

J2ME Desenvolvimento GUI