Curso J2ME

Prévia do material em texto

Links https://www.youtube.com/playlist?list=PL67A7ACBAA5DB4205 
Link do curso http://www.globalcode.com.br/gratuitos/minicursos/minicurso-desenvolvimento-de-aplicacoes-moveis-com-javaME 
	Os ambientes de testes em J2ME
Módulo 02 - J2ME Wireless Toolkit
O J2ME oferece dois tipos de ambientes de teste:
 Ambiente Linha de comando (Command line environment) 
 Ambiente Visual (Visual environment)
O Ambiente linha de comando
Este é um ambiente simples no qual um usuário digita um comando para realizar a tarefa desejada. Isto é semelhante às versões anteriores do Java onde a codificação ocorre em um editor de texto e a compilação é realizada usando comandos em linhas.
 
O Ambiente visual
 
O J2ME Wireless Toolkit oferece uma plataforma visual para compilar e testar MIDlets e um GUI de fácil uso, que reduz consideravelmente a tarefa do desenvolvedor na construção e teste de MIDlets. Atualmente, os seguintes ambientes visuais estão disponíveis em J2ME:
 KToolbar 
 Forte for Java 
 CodeWarrior for Java 
 Jbuilder Handheld Exp
	KToolbar
Módulo 02 - J2ME Wireless Toolkit
O KToolbar oferece um ambiente visual simples para testar MIDlets. Ele tem funções limitadas se comparado às oferecidas pelo Forte for Java, o mais recente ambiente visual da Sun Microsystems. Ele gerencia arquivos de código fonte e automatiza o processo de criação de MIDlets. Porém, não tem um editor próprio. Por isto, o código tem que ser escrito em um editor de textos fora do ambiente KToolbar. O KToolbar oferece todos os utilitários necessários para realizar a pré-verificação e a emulação de um código. Para maiores informações, clique no botão Mais Informações.
	Apresentação de MIDlets
Módulo 03 - Trabalhando com MIDlets
Um MIDlet é um aplicativo MIDP que usa o perfil MIDP e a configuração CLDC.
Há algumas diferenças entre MIDlets e applets:
Um applet é um arquivo de classe Java embutido em uma página HTML. Por outro lado, o MIDlet é um arquivo de classe Java empacotado em um arquivo JAD (Java descriptor).
Um applet opera em um navegador de web. Por outro lado, um MIDlet opera em um Application Management Software (AMS) que é instalado em dispositivos MIDP. O AMS oferece um ambiente para Kilobyte virtual machines (KVM) e MIDlets.
Um applet é visualizado em um navegador ou ferramenta de visualização de applet. Por outro lado, um MIDlet é visto em aparelhos de mão que suportam CLDC e MIDP.
	MIDlets - Ambiente grafico de teste 
O ambiente de testes MIDlet oferece uma imagem de um aparelho de mão que tem um display e as teclas relacionadas. Um usuário interage com um MIDlet através da tela da imagem.
O javax.microedition.lcdui é um pacote que contém todos os componentes GUI que são suportados pelo MIDP. Algumas das principais classes deste pacote, que são usados para controlar o display gráfico do aparelho são:
Display: esta classe é usada para administrar o display e o input do usuário. Cada MIDlet ativo terá exatamente um exemplo da classe Display.
Screen: esta classe representa uma única tela de informações e age como uma classe base para outros importantes componentes GUI.
Canvas: esta classe representa uma superfície de desenho na imagem do aparelho. Você pode realizar operações gráficas, tais como mostrar imagens, desenhar linhas e curvas usando esta classe.
	A classe MIDlets
Módulo 03 - Trabalhando com MIDlets
A classe MIDlet é uma interface entre o ambiente run-time e o código de aplicativo. Esta classe também oferece uma interface de programação em um aplicativo MIDlet. Este simulador mostra o resultado na tela em forma de um aparelho de mão e, através do mouse, é possível testar as aplicações que usam recursos de teclado.
Saiba Mais
Um aplicativo MIDlet mostra o resultado na tela de um aparelho de mão e aceita inputs através do teclado. O teclado é ativado com um clique do mouse. Um teclado de um ambiente de teste MIDlet contém várias tipos de teclas, tais como:
Soft keys (teclas leves)
Control keys (teclas de controle)
Navigation keys (teclas de navegação)
Alphanumeric keys (teclas alfanuméricas)
As teclas de atalhos estão localizadas diretamente abaixo da tela do aparelho. As teclas de controle (função) são usadas para controlar as atividades nos aparelhos de mão. As teclas de navegação são usadas para movimentar para frente e para trás as várias telas ou mensagens. As teclas alfanuméricas são usadas para inserir dados.
	O ciclo de vida de um MIDlet
Módulo 03 - Trabalhando com MIDlets
O ciclo de vida de um MIDlet inclui três estágios:
Paused (em pausa)
Active (ativo)
Destroyed (destruído)
	O ciclo de vida de um MIDlet II
Módulo 03 - Trabalhando com MIDlets
O estado paused de um MIDlet implica que o aplicativo está temporariamente inativo. Um MIDlet começa a funcionar durante o estado active e termina quando ele chega no estado destroyed. Um MIDlet passa a maior parte do seu tempo nos estados paused e active. Enquanto um novo MIDlet é carregado, ele fica inicialmente no estado paused.Um MIDlet no estado active ou paused pode ser destruído se ele não for mais necessário. Além disso, um novo MIDlet também pode ser destruído, se for preciso, antes de entrar no estado paused.
Um MIDlet pode passar pelos estados paused eactive várias vezes. Mas, depois que um MIDlet entrar no estado destroyed, ele não pode voltar para os outros estados.
O código a seguir representa a estrutura de uma classe MIDlet:
No código acima, SimpleMIDlet() é o construtor público padrão.
Aplicativos MIDlet são derivados da classe básica abstrata javax.microedition.midlet.MIDlet. Esta classe contém os métodos usados pelo MIDP para controlar as atividades do ciclo de vida do MIDlet.
public class SimpleMIDlet extends MIDlet 
    {
    SimpleMIDlet()
    {
    }
    protected void startApp() throws 
    MIDletStateChangedException
    {
    } 
    protected void pauseApp()
    {
    } 
    protected void destroyApp(boolean 
    unconditional)throws 
    MIDletStateChangedException
    {
    }
}
	Estrutura de código de um MIDlet
Módulo 03 - Trabalhando com MIDlets
Considere a seguinte linha de código:
protected void startApp() throws MIDletStateChangedException 
A exceção MIDletStateChangedException ocorre quando um MIDlet deixa de mudar seu estado de paused paraactive. Esta mudança de estado é captada pelo método startApp().
Considere a próxima linha do código:
protected void pauseApp()
Esta linha é usada para pausar um MIDlet. Isto permite que o MIDlet libere recursos tais como memória ou encerre uma conexão de rede de forma que outro MIDlet não possa usar a memória disponível e os recursos do aparelho.
O código a seguir é usado para encerrar um MIDlet:
protected void destroyApp(boolean unconditional)throws MIDletStateChangedException
Da mesma forma que o método startApp(), o método destroyApp(boolean unconditional)é usado para captar a mudança de estado quando o MIDletStateChangedException ocorre.
Todos os métodos descritos são abstratos e devem ser implementados na classe derivada de Midlet. O AMS chama estes métodos para mudar o estado de um Midlet. Quando o método destroyApp() é chamado com um parâmetro falso, o Midlet pode solicitar que o AMS permita que o Midlet exista no estado presente lançado uma exceção do tipo MIDletStateChangeException.
	Aplicativos móveis
Módulo 04 - Desenvolvendo midles usando o ktoolbar
O SaveMyMoney Bank introduziu seus serviços bancários móveis para possibilitar o acesso dos clientes aos serviços usando seus telefones celulares e criou uma senha exclusiva.
A equipe de desenvolvimento de aplicativo no SaveMyMoney Bank decidiu mostrar uma mensagem de boas-vindas como primeira tela e depois mostrar uma outra tela quando o usuário clica no botão com o nome Info, contendo uma mensagem para os clientes com relação a sua senha. Além disso, o aplicativo deve mostrar um texto no topo de ambas as telas e os usuários devem ter permissão para voltar da segunda paraa primeira tela. Os usuários devem ter a opção de encerrar os aplicativos de qualquer uma das telas.
Para o melhor entendimento dos requisitos acima, escreva um programa.
Orientações práticas
Identifique os requisitos do problema.
Identifique as mensagens a serem mostradas.
Determine os vários comandos e a interface a ser usada.
Codifique o MIDlet.
Execute o MIDlet.
Verifique o resultado.
	Estudo de caso - Passo a passo
Módulo 04 - Desenvolvendo midles usando o ktoolbar
	Estudo de caso - passo 2
Módulo 04 - Desenvolvendo midles usando o ktoolbar
2: Identifique as mensagens a serem mostradas 
Resultado
A mensagem a ser mostrada na primeira tela do aplicativo bancário móvel deve ser Welcome to SaveMyMoney Bank! A tela deve ter um texto com rolagem na parte superior mostrando a frase Welcome to the World of Mobile Banking! (Bem-vindo ao Mundo do Serviços Bancários Móveis!)
A mensagem a ser mostrada na tela deve ser:
Dear customer, you can view your personal account information by entering your PIN number and sending it to the number 9002. If you have not received the PIN number, please contact us at our head office.
Prezado cliente, você pode ver as informações da sua conta inserindo a sua senha e enviando-a para o número 9002. Caso você não tenha recebido a sua senha, favor entrar em contato com a nossa matriz.
 
A tela deve ter um texto com rolagem na parte superior mostrando a mensagem:
Note: your PIN number has been sent to you at your mailing address.
Observação: sua senha foi enviada para o seu endereço de correspondência.
	Estudo de caso - Passo 3
Módulo 04 - Desenvolvendo midles usando o ktoolbar
3: Determine os vários comandos e a interface a ser usada
Quando se cria aplicativos para aparelhos móveis, precisa-se oferecer a funcionalidade da navegação entre telas, seleção de itens específicos do menu, e encerramento do aplicativo. Para fazer tal tarefa, precisa-se usar comandos. Em J2ME, você pode implementar tais comandos usando classes de Command. A classe de comando Command implementa comandos usando o parâmetro commandType para chamar ações específicas do MIDlet com base no imput do usuário. Esta classe é definida no pacote javax.microedition.lcdui.
A classe Command fornece vários comandos usados para acessar as funcionalidades MIDlet. A criação de Command é feita usando o construtor Command(). Considere a seguinte linha:
Command(String label, int commandType, int priority);
Aqui, o parâmetro label especifica o rótulo do comando que o usuário visualiza.
	O parâmetro commandType define o valor para o tipo de comando usado de uma lista de tipos de constantes que é mostrado abaixo:
 ITEM: a tela display é composta de uma coleção de itens individuais, como o título da tela e a mensagem a ser mostrada. O comando item, que é específico do aplicativo, permite você especificar cada item individual da tela atual. 
 SCREEN: este comando é usado para especificar a tela atual no display. O comando screen é semelhante ao comando item.
 OK: indica permissão para realizar uma ação.
 CANCEL: indica permissão para cancelar uma ação.
 STOP: indica permissão para interromper uma ação. 
 EXIT: indica permissão para sair de um aplicativo MIDlet.
 BACK: indica permissão para voltar para uma tela anterior.
 HELP: indica o pedido de ajuda on line.
	Sintaxe dos comandos
Módulo 04 - Desenvolvendo midles usando o ktoolbar
O construtor Command(), que aceita o rótulo commandType e parâmetros priority, é chamado para criar um comando. O código a seguir é usado para criar um comando Help usando o construtor Command():
Command helpCmd = new Command (-Help-, Command.HELP, 1);
Neste exemplo, a sequência Help é dada como rótulo. Essa constante é usada para definir o tipo de comando, e ele recebe o valor de prioridade 1.
O método addCommand() adiciona um comando à tela. O objeto Command é o único argumento para este método. O código a seguir mostra o uso do método addCommand() para adicionar o objeto helpCmd à tela:
screen.addCommand (helpCmd);
Esta linha mostra o comando Help na tela.
Depois de adicionar o comando, o método commandAction() deveria ser chamado para especificar a ação a ser realizada se o comando fosse chamado. O processo de responder a um comando envolve a seguinte série de passos:
Implementar a Interface CommandListener na classe MIDlet. Para fazer isto, pode-se usar o seguinte comando:
public class CmdMidlet extends MIDlet implements CommandListener{}
Definir o comando listener à tela atual. Conforme mostrado no comando a seguir:
screen.setCommandListener(this);
Aqui, o parâmetro this especifica a classe MIDlet.
Sintaxe dos comandos II
A sintaxe para a implementação do método commandAction() é dada abaixo:
Na sintaxe, todo comando é checado dentro do método commandAction() usado no MIDlet. Isto é feito para identificar o tipo de comando selecionado pelo usuário dentre um conjunto de comandos fornecidos para chamar a resposta adequada.
 Definir o método commandAction() conforme abaixo:
void commandAction(Command cmd, Displayable displayable)
Neste exemplo, cmd é o objeto de comando, e displayable é o objeto a ser mostrado que contém a tela para o comando.
public void commandAction(Command cmd, Displayable displayable) 
{
    if (cmd == exitCmd)
    {
    // Invoke the actions to destroy the MIDlet and exit the
    application
    }
    else if (cmd == helpCmd)
    {
    // Invoke the command to display the online help
    }
}
Classe ticker
A classe Ticker é usada para mostrar uma linha de texto com rolagem na tela. Ela é uma classe independente e é usada juntamente com uma classe derivada de tela. Ela não pode ser derivada de qualquer outra classe MIDP GUI e é mostrada na parte superior de um componente da classe Screen.
O construtor Ticker() é usado para criar um Tickerque aceita texto como o único argumento:
Ticker(String strScroll);
O ticker criado é definido para a tela usando o método setTicker() como dado abaixo:
txtBox.setTicker(ticker);
Aqui, txtBox é o objeto TextBox sobre o qual o ticker é definido.
Os métodos getString() e setString() são usados para obter e configurar o texto que é mostrado em um ticker.
Resultado
Para atender às exigências deste aplicativo, você precisa usar as classes Ticker and Command. Você vai usar o método setTicker() para definir o texto com rolagem na parte de cima da tela. Para definir os vários comandos para o aplicativo, você precisa implantar a interface CommandListener da classe de comando.
Você também deve usar os comandos CommandAction() e setCommandListener() desta classe para garantir que ações adequadas são realizadas quando os comandos são chamados.
Uso de MIDlet
Antes de proceder para a escrita do código para este estudo de caso, você precisa identificar os vários comandos e a classe Ticker a ser usada. Primeiro implanta-se a interface CommandListener na classe MIDlet. Isto pode ser feito usando alinha de comandos a seguir:
public class MB extends MIDlet implements CommandListener{}
Observe que na declaração da classe, o nome da classe MIDlet foi especificado como MB. Então você deve dar às variáveis membros para serem usados.
São os mencionados abaixo:
Display display;
Form form1;
Form form2;
Ticker ticker1;
Ticker ticker2;
static final Command okCommand = new Command("Info",Command.OK,1);
static final Command backCommand = new command("Back",Command.BACK,0);
static final Command exitCommand = new Command("Exit", Command.STOP, 2);
No código acima, display é o exemplo da classe Display e form1 e form2 são os objetos javax.microedition.lcdui.Form, que representam as telas principais do MIDlet. O ticker1 e ticker2 são exemplos da classe Ticker. As últimas três linhas são usadas para criar comandos como okCommand, backCommand, e exitCommand. As sequências como -Info-, -Back-, e -Exit- são dadas como rótulos. As constantes OK, BACK, e STOP são usadas para definir o tipo de comando. Todos estescomandos receberam níveis de prioridade 1, 0, e 2 respectivamente.
As mensagens a serem mostradas como Ticker são dadas usando as seguintes linhas:
ticker1 = new Ticker("Welcome to the World of Mobile Banking!");
ticker2 = new Ticker("Note: Your PIN number has been sent to you at your mailing address.");
Essas linhas devem ser dadas dentro do método startApp(), se elas tiverem que ser mostradas quando o aplicativo começa. Depois, deve-se criar um componente StringItem, adicionar comandos e definir o Ticker. Considere o código a seguir:
StringItem strItem = new StringItem("Welcome to SaveMyMoney Bank!", "");
StringItem strItem1 = new StringItem("Dear Customer", "You can view your personal account information by entering your PIN number and sending it to the number 9002. If you have not received the PIN number, please contact us at our Head Office.");
form1.append(strItem);
form2.append(strItem1);
form1.addCommand(exitCommand);
form1.addCommand(okCommand);
form1.setCommandListener(this);
form1.setTicker(ticker1);
display.setCurrent(form1);
As mensagens são mostradas nas telas usando a classe StringItem. Os objetos da classe Form, strItem e strItem1 são componentes recém criados. Estes componentes recém criados são adicionados às telas usando o método append(). Depois os comandos são adicionados às telas usando o método addCommand().
Respostas dos comandos
Os comandos respondem somente se o métodosetCommandListener() for dado. Ele é usado para definir o comando da tela atual. Depois de usar o método setCommandListener(), você precisa definir a sequência a ser mostrada como o Ticker na tela. O método setTicker() é usado para definir oTicker na tela. O método setCurrent() é usado para definir o display atual na tela principal. 
Agora, você precisa declarar os métodosshowForm1() e showForm2(), adicionar os comandos e definir o commandListener. Considere o código dado ao lado:
public void showForm1()
{
form1.addCommand(exitCommand);
form1.addCommand(okCommand);
form1.setCommandListener(this);
display.setCurrent(form1);
}
public void showForm2()
{
form2.addCommand(exitCommand);
form2.addCommand(backCommand);
form2.setCommandListener(this);
form2.setTicker(ticker2);
display.setCurrent(form2);
}
O Ticker para a primeira tela já foi definido. OTicker para a segunda tela é definido usando o método setTicker() no método showForm2(). Você também deve definir o display atual para ambas as telas.
Depois de declarar os métodos showForm1() eshowForm2(), você precisa implementar o método commandAction(). Considere o código a seguir:
public void commandAction(Command cmd, Displayable displayable) 
{
String label = cmd.getLabel();
if (label.equals("Exit")) 
{
destroyApp(true);
}
else if (label.equals("Back")) 
{
// go back to Form1
showForm1();
}
else
{
showForm2();
}
}
O método getLabel() é usado para obter o rótulo do comando.
Os forms são mostrados adequadamente usando as construções if else if checando o rótulo do comando. Se o rótulo é igual a -Exit-, o aplicativo é encerrado. Se o rótulo é igual a -Back-, o display retorna para a primeira tela. Se o rótulo não for igual a -Back- ou -Exit-, a segunda tela aparece.
A execução e teste de um MIDlet podem ser realizados através de um ambiente virtual, como a ferramenta Ktoolbar, que vem com o 2ME Wireless Toolkit.
Os passos para executar o MIDlet em um KToolbar são os seguintes:
Para abrir a caixa de diálogo New Project, clique no botão New Project.
Insira o Project Name como MOBBANK e o MIDlet Class Name como MB.
Clique no botão Create Project.
Salve o arquivo do código fonte para o MIDlet como MB.java no diretório nomeado src colocado emMOBBANK.
Depois que o arquivo é colocado em seu respectivo diretório, clique no botão Open Project na barra de ferramentas.
Selecione MOBBANK e clique em OK para abrir o projeto.
Neste módulo, você aprendeu que:
Um MIDlet é um aplicativo MIDP que usa o perfil MIDP e a configuração CLDC.
A classe Display é usada para gerenciar o display e o input do usuário. Cada MIDlet ativo terá exatamente um exemplo da classe Display.
Cada tela representa uma única tela de informações e funciona como uma classe de base para outros importantes componentes GUI.
A classe Canvas representa uma superfície para desenho na imagem da tela do aparelho. Você pode realizar operações gráficas como mostrar imagens e desenhar linhas e curvas, usando esta classe.
 O ciclo de vida de um aplicativo MIDlet inclui três fases:
Paused (em pausa)
Active (ativo)
Destroyed (destruído)
 A classe Command implementa o comando, que é um componente MIDP GUI usado para chamar ações específicas MIDlet no input do usuário.
 A classe de comando oferece vários comandos para acessar as funcionalidades MIDlet.
 Os parâmetros prioridade de um comandopermitem que o gerenciador de aplicativos de um aparelho decida qual a prioridade atribuída para aquele comando específico no aplicativo.
O aparelho decide a ordem de colocação de um comando com base nos tipos de comando. Se dois comandos são do mesmo tipo, eles são colocados com base no seu grau de prioridade.
O construtor Command() aceita o rótulo commandType e parâmetros priority parameters para criar um comando.
A classe Ticker é usada para mostrar uma linha de texto com rolagem na tela.
O construtor Ticker() é usado para criar um Ticker que aceita o texto com rolagem como único argumento.
A compilação e teste de MIDlets podem ser feitos usando-se tanto o ambiente de linha de comando como oKToolbar.