Conexão Java Mini-curso Java ME

Transcrição

1 Conexão Java 2006 Mini-curso Java ME Sérgio Luís Lopes Júnior Caelum Neste tutorial, você irá aprender: - conceitos básicos de Java ME - a utilizar alguns componentes do MIDP para criar um Form; - como usar comandos para receber ações do usuário. Java ME Java ME (antigamente J2ME) é a esfera que rege o Java em dispositivos portáteis ou de pouca performace e limitado. Para rodar Java em um pequeno dispositivo, precisamos de uma configuração e de um profile. CLDC Connected Limited Device Configuration é a especificação para pequenos dispositivos. Tem toda a especificação de infraestrutura e de como a máquina virtual deve agir, além de colocar limitantes mínimos para que um dispositivo possa se enquadrar aqui: Processador de 16 ou 32 bits com no mínimo 16MHz 160Kb de memória para a virtual machine e biblitoecas 192kb para o heap Pouco poder de bateria Algum tipo de conectividade, provavelmente wireless, com limite de banda (velocidade) e com instabilidade Em outras palavras: celulares e PDAs mais simples. Uma configuração também fornece a API básica que os dispositivos devem ter. MIDP Um profile é algo menos abrangente que uma configuração. Cada dispositivo possui um ou mais profiles, que vai definir as bibliotecas java que aquele aparelho vai disponibilizar. Mobile Information Device Profile define a cara de um dispositivo móvel, especificando bibliotecas java (pacotes) que o desenvolvedor terá acesso. Um dispositivo define suas capacidades Java através de uma configuração e um profile. Atualmente os celulares e palms estão vindo com CLDC 1.1 e MIDP 2.0.

2 Nosso ambiente Usaremos a IDE Eclipse ( para o desenvolvimento de nossos programas J2ME. O suporte a J2ME no Eclipse é dado pelo ótimo plugin EclipseME ( que será incorporado ao projeto eclipse futuramente. Além da IDE, usamos o Sun Java Wireless Toolkit ( o WTK, que provê uma série de ferramentas necessárias ao desenvolvimento em J2ME (mais adiante iremos detalhar essas ferramentas) facilitando o download agrupado. Instalação do WTK Pegue o arquivo do WTK e execute seu instalador. Siga os passos na tela e lembre o local escolhido para instalação. Configuração do Eclipse Vamos agora configurar o Eclipse com o plugin EclipseME para desenvolvimento de Midlets. (Fora da Caelum, esteja certo de ter o Eclipse e o EclipseME já instalados) Abra o menu J2ME e clique no botão Browse... da seção WTK Root: Selecione o diretório WTK2.2.

3 Agora selecione no menu J2ME, Device Manager: Agora clique em Import..., que surgirá essa tela:

4 Clicando em Browse, você deve selecionar o diretório de instalação do WTK, e clicar logo abaixo em Refresh: Clique em Finish:

5 Hello World Clique em OK. Pronto! Nosso Eclipse está configurado! Vamos fazer nosso Hello World para testá-lo. Vá em File -> New -> Project e selecione J2ME Midlet Suite:

6 Clique em Next e coloque o nome do Projeto como HelloWorld. Clique em Finish: Vamos criar nosso primeiro Midlet, uma aplicação J2ME que rodará em pequenos dispositivos. Para isso, vá em File -> New -> Other e selecione J2ME Midlet:

7 Após clicar em Next, coloque o nome do pacote e o nome de nossa classe, desta forma:

8 O código de nosso HelloWorld está abaixo. Não se preocupe em entendê-lo agora, apenas transcreva-o como segue. Este exemplo mostrará uma janela (TextBox) com o título Hello World Midlet e o texto Oi Mundo! package br.com.caelum.fj55; import javax.microedition.lcdui.display; import javax.microedition.lcdui.textbox; import javax.microedition.midlet.midlet; public class HelloWorld extends MIDlet { protected void startapp() { TextBox tbox = new TextBox("Hello World MIDlet", "Oi Mundo!", 25, 0); Display.getDisplay(this).setCurrent(tbox); /* Deixe esses métodos em branco */ protected void pauseapp() { protected void destroyapp(boolean bool) {

9 Atenção: se você criar a Midlet sem usar o wizard, você vai precisar manualmente adicionar a MIDLet no deployment descriptor (manifesto e.jad). Você não terá problemas para executá-la pelo emulador, porém se for fazer deploy em um celular o jad/manifesto precisa estar corretamente configurado ou você receberá um erro, já que a VM não vai saber o que executar e a aplicação ira falhar. Testando nosso Hello World Vamos testar nosso Midlet no emulador que vem com o WTK da Sun. O EclipseME provê uma forma fácil de fazer isso. Clique com o botão direito na classe HelloWorld.java, selecione Run As e depois clique em Emulated J2ME Midlet: Aparecerá um emulador de celular com nossa aplicação. Repare que a saída no console do Eclipse ainda vai te trazer uma série de informações ao término da aplicação, tais como quantidade de opcodes executados, quantas vezes o GC passou, quantas vezes o escalonador trocou de Threads, etc: Running with storage root DefaultGrayPhone Execution completed bytecodes executed

10 15 thread switches 740 classes in the system (including system classes) 3803 dynamic objects allocated ( bytes) 2 garbage collections (86300 bytes collected) Ciclo de vida de um MIDlet Um Midlet é bastante diferente de aplicações Java comuns, iniciadas pelo famoso método main. Você notou no HelloWorld que um Midlet estende a classe javax.microedition.midlet.midlet e implementa alguns métodos especiais. Todo Midlet roda no dispositivo móvel gerenciado por um aplicativo especial do dispositivo. O dispositivo é responsável por instanciar seu Midlet, executá-lo, pausá-lo e destruí-lo. Um Midlet tem o que é chamado de Ciclo de Vida que é gerenciado pelo dispositivo. Esse Ciclo de Vida descreve todos os estados possíveis de um Midlet desde o instante em que é criado até sua destruição. São três estados possíveis: Ativo, Pausado e Destruído. A mudança de estados é feita justamente com aqueles métodos sobrescritos da classe MIDlet. Veja o diagrama de estados do ciclo de vida de um midlet e os métodos invocados nas mudanças de estado: O dispositivo é o responsável por instanciar o Midlet. Isso é feito sempre pelo construtor sem argumentos. Neste instante, o Midlet é colocado no estado Pausado. Análise do Hello World Todo aplicativo a ser rodado no celular é chamado de MIDLET. Você escreve uma classe e obrigatoriamente estende da classe javax.microedition.midlet.midlet e implementa os três métodos vistos antes: startapp, pauseapp e destroyapp. No nosso HelloWorld, o método startapp tem duas linhas simples. Na primeira, criamos um TextBox, uma caixa de texto que toma a tela toda do dispositivo. O primeiro argumento indica o título da caixa de texto, o segundo o texto inicial, o terceiro o tamanho máximo de caracteres permitidos e o último algumas restrições possíveis (no nosso caso, nenhuma, por isso 0). Na segunda linha, pegamos o Display da nossa MIDlet e exibimos o TextBox. O Display é a tela de nosso dispositivo, e o obtemos chamando o método estático getdisplay na classe Display.

11 Screen Além do TextBox, há outros elementos que podemos usar que são exibidos em todo nosso Display. Todos esses elementos têm em comum o fato de serem filhos de Screen. Além de caixa de texto, temos mais três elementos: Alert (uma mensagem de alerta que logo sai da tela), List (exibe uma lista de itens) e Form (para fazermos um formulário). Veja um screenshot de um List, por exemplo: Nosso projeto: pesquisa de campo Form Nesse tutorial, vamos desenvolver um projeto de uma pesquisa de campo feita através de um Form. Imagine uma empresa de pesquisa eleitoral que queira coletar em campo dados de intenção de voto para as eleições. Vamos implementar um Form usando componentes do MIDP que facilite a coleta das informações. No nosso sistema, antes de efetivamente responder em qual candidato o pesquisado irá votar, temos que fazer algumas perguntas para fins estatísticos. Por exemplo, qual sua idade e qual sua renda mensal. A classe Form é a última filha de Screen (e neta de Displayable) disponível no MIDP. Um formulário é uma tela especial onde podem ser adicionados itens de diversos tipos (através do método append). Há vários itens disponíveis (como campos de texto ou de data) e todos herdam da classe abstrata Item. Como todo Screen, um Form possui um título. O construtor de Form recebe o título como parâmetro: Form form = new Form("Pesquisa eleitoral"); E precisamos agora colocar o Form como elemento visível no Display, com o código que já vimos antes: Display.getDisplay(this).setCurrent(form); Perguntando a renda mensal Para coletar o dado sobre a renda mensal, vamos utilizar uma caixa de texto. Anteriormente vimos a classe TextBox, um Displayable. Existe a classe TextField,

12 bastante semelhante, em funcionamento, ao já visto TextBox, mas com a vantagem de poder ser adicionado a um Formulário (não ocupará a tela toda). O construtor recebe o label, o valor inicial, o tamanho máximo e restrições que definem seu comportamento. Neste exemplo, vamos usar uma restrição. Restrições são constantes que definem o comportamento do TextField. Há uma constante, por exemplo, que define que só podemos inserir valores numéricos no campo. Vamos usá-la: TextField renda = new TextField("Qual sua renda mensal?","", 10, TextField.NUMERIC); form.append(renda); As constantes ficam todas na classe TextField; há várias. Por último, adicionamos o TextField ao Form para ser exibido: Perguntando a data de nascimento Para perguntarmos a data de nascimento, vamos usar um componente do MIDP para datas, o DateField. Seu construtor recebe dois argumento: primeiro o label e depois o modo de operação. Podemos usar três modos de operação: DATE, TIME e DATE_TIME, todas constantes na classe DateField. No nosso caso, queremos coletar apenas a data, sem o horário. Vamos fazer: DateField nascimento = new DateField("Data de nascimento:", DateField.DATE); form.append(nascimento); Perguntando o voto Para perguntarmos o voto, vamos usar uma lista de opções onde se poderá selecionar apenas uma (lista exclusiva). O Item que incorpora esse comportamento é o ChoiceGroup. Trabalhar com o ChoiceGroup é bastante simples. Primeiro precisamos indicar no construtor qual é o label e o modo de operação. Os modos disponívels são: EXCLUSIVE (lista exclusiva, uma opção), MULTIPLE (múltipla escolha) e IMPLICIT (muito usado em menus). Note que as constantes estão definidas na interface Choice. Vamos usar uma lista EXCLUSIVE: ChoiceGroup voto = new ChoiceGroup("Voto:", Choice.EXCLUSIVE); Precisamos agora adicionar os elementos nesse ChoiceGroup, as opções de voto. Fazemos isso com o método append que recebe também uma imagem a ser exibida (vamos colocar null para não exibir nenhuma imagem): voto.append("candidato 1", null); voto.append("candidato 2", null); voto.append("branco", null); voto.append("nulo", null);

13 Por último, precisamos adicionar o ChoiceGroup ao form: form.append(voto); Exercício Vamos implementar nosso projeto de coleta de votos usando um TextField, um DateField e um ChoiceGroup. 1) Crie uma MIDlet chamada PesquisaEleitoral: - Vá em File -> New -> Other - Dentro de J2ME, selecione J2ME MIDlet - Coloque o nome do pacote como br.com.caelum.fj55 - Coloque o nome da classe como PesquisaEleitoral 2) Vamos implementar a classe: - crie atributos para Form, TextField, DateField e ChoiceGroup private Form form; private TextField renda; private DateField nascimento; private ChoiceGroup voto; - Dentro do construtor da classe, inicialize essas variáveis e adicione os Items ao form: public PesquisaEleitoral() { // cria o Form form = new Form("Pesquisa eleitoral"); // cria o campo para renda renda = new TextField("Qual sua renda mensal?","",10,textfield.numeric); // cria o campo para data de nascimento nascimento = new DateField("Data de nascimento:", DateField.DATE); // cria o campo para o voto voto = new ChoiceGroup("Voto:", Choice.EXCLUSIVE); // adiciona opã ões de voto voto.append("candidato 1", null); voto.append("candidato 2", null); voto.append("branco", null); voto.append("nulo", null); // adiciona elementos no Form form.append(renda); form.append(nascimento); form.append(voto); - no método startapp, exiba o form na tela: protected void startapp() throws MIDletStateChangeException { Display.getDisplay(this).setCurrent(form);

14 O código final de sua classe deve ser: package br.com.caelum.fj55; import javax.microedition.lcdui.*; import javax.microedition.midlet.*; public class PesquisaEleitoral extends MIDlet { private Form form; private TextField renda; private DateField nascimento; private ChoiceGroup voto; public PesquisaEleitoral() { // cria o Form form = new Form("Pesquisa eleitoral"); // cria o campo para renda renda = new TextField("Qual sua renda mensal?","",10,textfield.numeric); // cria o campo para data de nascimento nascimento = new DateField("Data de nascimento:", DateField.DATE); // cria o campo para o voto voto = new ChoiceGroup("Voto:", Choice.EXCLUSIVE); // adiciona opções de voto voto.append("candidato 1", null); voto.append("candidato 2", null); voto.append("branco", null); voto.append("nulo", null); // adiciona elementos no Form form.append(renda); form.append(nascimento); form.append(voto); protected void startapp() throws MIDletStateChangeException { Display.getDisplay(this).setCurrent(form); protected void destroyapp(boolean arg0) throws MIDletStateChangeException { // TODO Auto-generated method stub protected void pauseapp() { // TODO Auto-generated method stub 3) Rode sua MIDlet e veja o resultado: - Clique com o botão direito na MIDlet e vá em: Run As... -> Emulated J2ME MIDlet - Teste cada um dos componentes

15 O que são Comandos Até agora nossas aplicações foram bastante inúteis, apenas mostravam elementos na tela sem fazer nada realmente. Para executarmos ações em nossos Midlets, nossa aplicação recebe comandos do usuário. Comandos são definidos pela classe Command. Comandos são ações que o usuário pode executar na tela em que ele está. São geralmente opções exibidas na parte de baixo da tela através de links ou menus. Um Midlet pode criar diversos comandos e adicioná-los ao Displayable atual (TextBox, Form etc). Dependendo do dispositivo e do número de comandos, estes podem ser apresentados associados à botões de navegação do aparelho ou em um menu. Criando Comandos Para criar um Command, usamos o único construtor da classe: Command(String label, int tipo, int prioridade) O primeiro argumento é o nome do comando a ser exibido. Este deve ser o menor possível (de preferência, apenas uma palavra de ação). O tipo é definido por constantes dentro da classe Command. O MIDP oferece vários tipos comuns de comandos (como OK ou CANCEL). Esses tipos servem para instruir o dispositivo a exibir o comando como costuma fazer com comandos do mesmo tipo (pode exibir em um lugar de destaque, associar a uma tecla específica etc). Os tipos são constantes inteiras na classe Command. São eles: BACK: OK: leva o usuário à tela logicamente anterior à atual resposta positiva à tela atual CANCEL: resposta negativa à tela atual HELP: apresenta ajuda STOP: para um processo/operação em execução EXIT: sair da aplicação Há ainda mais duas constantes que não definem um tipo especial como os anteriores: SCREEN: indica um comando específico da aplicação para a tela atual ITEM: indica um comando específico para um item da tela ou elemento de Choice No caso dos tipos específicos de comandos, o dispositivo pode optar por sobrescrever o label na hora da exibição por algum label padrão.

16 Nota sobre tipos Note que o tipo tem a única finalidade de dar a possibilidade ao dispositivo de manter a consistência de navegação/exibição de comandos similares com outras aplicações; não implica em ação alguma (a ação será definida depois). Disparando ações O último argumento do construtor, prioridade, serve para indicar ao dispositivo a importância/relevância de cada comando. Comandos com prioridade igual a 1 poderão ser destacados pelo dispositivos (que pode associá-los a soft keys por exemplo). Conforme o valor da prioridade aumenta, menos importante é o comando (e o dispositivo pode optar por colocá-lo em um menu, por exemplo). Um Comando é adicionado a um objeto Displayable com o método addcommand(command). No nosso caso, vamos criar um comando que, quando disparado, exiba os dados preenchidos anteriormente no Form. Primeiro vamos criar o Command e adicioná-lo ao Form. Será um comando de OK: Command ok = new Command("Salvar", Command.OK, 1); form.addcommand(ok); Se você implementar só essa modificação, notará que o comando já aparece na tela, como um comando normal de celular. Mas ao clicar no comando, nada acontece. Isso porque precisamos tratar os comandos disparados. A interface CommandListener define um ouvinte que captura todo comando disparado pelo usuário. Há apenas um método: commandaction(command c, Displayable d) Esse método recebe como argumento o Command que foi disparado e o Displayable onde ele foi disparado (um comando pode ser inserido em várias telas, portanto é interessante saber que tela disparou o comando). O CommandListener é adicionado ao objeto Displayable através do método: setcommandlistener(commandlistener cl) Nós vamos fazer a nossa própria MIDlet tratar os comandos, implementando a interface CommandListener ela mesma. Então precisamos indicar ao Form quem tratará os comandos: form.setcommandlistener(this); E no método commandaction fazemos apenas uns System.out.println para exibir os dados marcados: public void commandaction(command c, Displayable d) { // pega a renda digitada System.out.println("Renda: " + renda.getstring());

17 // pega o nascimento selecionado System.out.println("Nascimento: " + nascimento.getdate()); // pega o nome da opã Ã o selecionada System.out.println("Voto: " + voto.getstring(voto.getselectedindex())); Exercício Note a forma como pegamos os valores inseridos nos campos: - no TextField, através do getstring() - no DateField, através do getdate() - no ChoiceGroup, através do getstring(int) que recebe o índice da opção que queremos. E para pegar a opção selecionada, usamos o getselectedindex() no caso de listas EXCLUSIVE 1) Abra sua classe PesquisaEleitoral. Faça-a implementar a interface CommandListener: public class PesquisaEleitoral extends MIDlet implements CommandListener { //... 2) Implemente o método commandaction como visto acima: public void commandaction(command c, Displayable d) { // pega a renda digitada System.out.println("Renda: " + renda.getstring()); // pega o nascimento selecionado System.out.println("Nascimento: " + nascimento.getdate()); // pega o nome da opã Ã o selecionada System.out.println("Voto: " + voto.getstring(voto.getselectedindex())); 3) Vá até o construtor da classe e adicione, no final do construtor, a criação do Command: // cria o Command e coloca no form Command ok = new Command("Salvar", Command.OK, 1); form.addcommand(ok); form.setcommandlistener(this); package br.com.caelum.fj55; O código final de sua classe deve ser agora: import javax.microedition.lcdui.*; import javax.microedition.midlet.*; public class PesquisaEleitoral extends MIDlet implements CommandListener {

18 private Form form; private TextField renda; private DateField nascimento; private ChoiceGroup voto; public PesquisaEleitoral() { // cria o Form form = new Form("Pesquisa eleitoral"); // cria o campo para renda renda = new TextField("Qual sua renda mensal?","",10,textfield.numeric); // cria o campo para data de nascimento nascimento = new DateField("Data de nascimento:", DateField.DATE); // cria o campo para o voto voto = new ChoiceGroup("Voto:", Choice.EXCLUSIVE); // adiciona opã ões de voto voto.append("candidato 1", null); voto.append("candidato 2", null); voto.append("branco", null); voto.append("nulo", null); // adiciona elementos no Form form.append(renda); form.append(nascimento); form.append(voto); // cria o Command e coloca no form Command ok = new Command("Salvar", Command.OK, 1); form.addcommand(ok); form.setcommandlistener(this); protected void startapp() throws MIDletStateChangeException { Display.getDisplay(this).setCurrent(form); public void commandaction(command c, Displayable d) { // pega a renda digitada System.out.println("Renda: " + renda.getstring()); // pega o nascimento selecionado System.out.println("Nascimento: " + nascimento.getdate()); // pega o nome da opã à o selecionada System.out.println("Voto: " + voto.getstring(voto.getselectedindex())); protected void destroyapp(boolean arg0) throws MIDletStateChangeException { // TODO Auto-generated method stub protected void pauseapp() { // TODO Auto-generated method stub

19 4) Teste sua MIDlet. - Clique com o botão direito na MIDlet e vá em: Run As... -> Emulated J2ME MIDlet - Teste cada um dos componentes Coloque alguns valores e dispare o comando salvar. Observe no console do Eclipse a saída. Adicional: exibir em um TextBox Ao invés de imprimir no console, podemos exibir os dados em um TextBox. Para isso, mude a implementação do tratador de eventos (método commandaction) para criar um TextBox e exibir as mensagens. Não esqueça que, como o Form está sendo exibido, para mostrarmos o TextBox, precisamos passá-lo para o setcurrent do Display. Nosso método fica assim então: public void commandaction(command c, Displayable d) { String mensagem = "Renda: " + renda.getstring() + "\n" + "Nascimento: " + nascimento.getdate() + "\n" + "Voto: " + voto.getstring(voto.getselectedindex()); TextBox box = new TextBox("Dados inseridos", mensagem, mensagem.length(), 0); Display.getDisplay(this).setCurrent(box); Note que passamos para o construtor a String mensagem com a mensagem que queremos exibir e colocamos o valor máximo como sendo o tamanho da mensagem. Adicional: comando voltar Rode seu MIDlet e veja o resultado. Implemente um comando voltar no TextBox que exibe a mensagem. Esse comando, quando disparado, deve exibir novamente o Form. Se desejar, faça esse comando limpar os campos do Form. Para saber mais: como salvar os dados Você pode persistir os dados no próprio celular usando a classe RecordStore. Todo celular com java ME possui uma espécie de banco de dados bem rudimentar que pode ser acessado através dessa classe. São os Records, ou registros. A estrutura dos registros é bastante simples. Não há tipo de dados, não há como adicionar campos e não há nenhuma forma de pesquisa já implementada. Cada registro possui um índice inteiro e um array de bytes. Podemos abrir um RecordStore da seguinte forma: RecordStore dados = RecordStore.openRecordStore( dados, true); E para adicionar uma String como registro:

20 String mensagem = alguma mensagem ; int posicao = dados.addrecord(mensagem.getbytes(), 0, mensagem.length()); E, para recuperar um registro, fazemos: byte[] arraydebytes = dados.getrecord(posicao); Além disso, você poderia querer enviar os dados via Internet para algum servidor remoto (o que é o mais comum). Isso pode ser feito com as classes Connector e HttpConnection. Pesquise sobre essas classes para saber como poderíamos salvar nossos dados. Para saber mais: Canvas e Jogos Em um Display, além de poder exibir Screens (TextBox, Form etc), podemos exibir também um Canvas. Ambos (Screen e Canvas) são filhos de Displayable, o que realmente define o que pode ser exibido ou não em um Display. Todos os componentes do lado Screen são relacionados ao uso de formulários, com componentes prontos. Já Canvas é a classe básica usada para eventos mais baixo nível, em geral para desenhar objetos na tela, tratar eventos do teclado. Jogos são os que mais dependem da classe Canvas, que permite fazer as animações e interações com o usuário. Nada impede, logicamente, que se usem, em uma mesma aplicação, objetos Screen e Canvas. O desenvolvimento de jogos foi tão importante para o J2ME que a especificação MIDP 2.0 acrescentou a classe GameCanvas, filha de Canvas. A GameCanvas provê grandes facilidades para o desenvolvimento de jogos e será vista mais a frente no capítulo de MIDP 2.0 Para saber mais: como fazer sem o plugin eclipseme Desenvolver MIDlets com o plugin eclipseme é muito simples. Mas se fossemos desenvolver na mão, usando o console, teríamos que tomar cuidado com algumas coisas. Primeiro na hora de compilar, precisamos gerar um bytecode compatível com a JVM 1.1 que é o que a KVM suporta. Fazemos isso passando -target 1.1 para o javac. Além disso, precisamos indicar que o bootclasspath não são as classes normais do Java e sim os jars do cldc e do midp. Depois da compilação, precisamos passar o pré-verificador no nosso.class. A pré-verificação é um processo que avalia se os bytecodes da classe são seguros de serem executados ou não (se não acessam endereços proibidos de memória, por exemplo). Em um programa Java normal, J2SE, essa verificação também existe, só que ela é executada automaticamente pela JVM no instante em que a classe é carregada. Mas esse processo é relativamente custoso e a KVM dos dispositivos que rodam J2ME não

21 pode se dar ao luxo de gastar tempo verificando bytecodes. Assim, é feita a pré-verificação dos bytecodes logo após a compilação, através de uma ferramenta do WTK chamada preverify. Por último, precisamos empacotar nossa aplicação em um jar e criar um arquivo descritor de nossa aplicação, o famoso jad (parecido com o formato do arquivo de manifesto). Como todos esses passos não são triviais, recomenda-se fortemente o uso de algum plugin para automatizar essas tarefas.