Aplicação J2ME para Iniciantes

Iremos aqui, trabalhar com uma aplicação j2ME que trabalha com Http Connection e Com RMS para entrada e armazenamento de dados. Valos lá!

Classe MIDLets.

  1. /* 
  2.  * 
  3.  * ControledeGastos.java 
  4.  * 
  5.  *
  6.  * 
  7.  */  
  8.   
  9. package midlet;  
  10.   
  11. import controleForm.AlteraFormulario;  
  12. import form.ComunicacaoServidorWeb;  
  13. import form.ReferenciaDespesas;  
  14. import form.RegistroDespesas;  
  15. import java.io.InputStream;  
  16. import javax.microedition.midlet.*;  
  17. import javax.microedition.lcdui.*;  
  18.   
  19. /** 
  20.  * 
  21.  *    Esta é a classe principal ou seja e o MIDLets propriamente dito, nele e onde temos o ciclo de vida do  
  22.  * MIDLets e por ele que manipulamos todo o aplicativo temos nela o método 
  23.  * “public void startApp()” que e o primeiro método a ser executado quando o aplicativo for aberto,  
  24.  * temos também o método “public void pauseApp()” que e solicitado quando tiver que interromper a  
  25.  * execução do aplicativo para fazer uma outra tarefa no aparelho como por exemplo atender uma ligação, 
  26.  * e temos o método “public void destroyApp(boolean unconditional)” que e executado quando esta sendo  
  27.  * fechado o aplicativo, são estes três métodos que compõem o ciclo de vida do MIDLets eles são  
  28.  * obrigatórios em um MIDLets. 
  29.  * Temos também o método “public void commandAction(Command c, Displayable s)” que e nele que pegamos  
  30.  * as ações efetuados pelo usuário. 
  31.  * E o método “private String lerArquivoHelp()” que e por ele que lemos o arquivo de HELP  
  32.  * que esta armazenado em uma arquivo (.TXT) 
  33.  * 
  34.  * 
  35.  */  
  36.   
  37. public class ControledeGastos extends MIDlet implements CommandListener {  
  38.      
  39.    private Display display = null;  
  40.    private Form formMaim   = null;  
  41.    private Ticker ticker   = null;   
  42.    private Image image     = null;  
  43.    private Alert alerta    = null;  
  44.    private Command commExit, commControleDeGasto,   
  45.            commDescricaoGasto, commLogin, commHelp;  
  46.    private AlteraFormulario alteraFormulario = null;  
  47.      
  48.      
  49.    public ControledeGastos(){  
  50.        display  = Display.getDisplay(this);  
  51.        formMaim = new Form( "Controle de Despesas" );  
  52.        formMaim.addCommand( commExit = new Command("Sair", Command.EXIT, 0) );  
  53.        formMaim.addCommand( commControleDeGasto = new Command( "Controle de Gasto", Command.OK, 1) );       
  54.        formMaim.addCommand( commDescricaoGasto = new Command( "Referência de Gasto",Command.OK, 1) );  
  55.        formMaim.addCommand( commLogin = new Command( "Acesso Servidor Web",Command.OK, 1) );  
  56.        formMaim.addCommand( commHelp = new Command( "Help",Command.HELP, 1) );  
  57.        formMaim.setTicker( ticker = new Ticker( "Ederson Thomazini, Fernando Schutz.MS & Adriano Sabo" ) );          
  58.        try{  
  59.          image = Image.createImage( "/imagem/Inicial.png" );  
  60.        }catch (Exception e) { }        
  61.        formMaim.append(new ImageItem( null, image, ImageItem.LAYOUT_CENTER, null) );  
  62.        formMaim.setCommandListener( this );       
  63.        alteraFormulario = AlteraFormulario.instancia(display, formMaim);   
  64.    }  
  65.   
  66. //******************************************************************************  
  67.      
  68.    public void startApp() {  
  69.       display.setCurrent(formMaim);  
  70.    }  
  71.       
  72.    public void pauseApp() { }  
  73.       
  74.    public void destroyApp(boolean unconditional) { }  
  75.   
  76. //******************************************************************************  
  77.      
  78.    public void commandAction(Command c, Displayable s){  
  79.       if (c == commExit){  
  80.          destroyApp(false);  
  81.          notifyDestroyed();     
  82.       }else if (c == commControleDeGasto){  
  83.          alteraFormulario.pushForm( new RegistroDespesas("Total R$:0.00"this, ticker) );        
  84.       }else if (c == commDescricaoGasto){  
  85.          alteraFormulario.pushForm( new ReferenciaDespesas("Referência de Despesas."this, ticker));            
  86.       }else if (c== commLogin){  
  87.           alteraFormulario.pushForm( new ComunicacaoServidorWeb("Acesso Servidor Web."this, ticker));   
  88.       }else if (c == commHelp) alerta(lerArquivoHelp(), formMaim);          
  89.     }      
  90.       
  91.    private String lerArquivoHelp(){  
  92.       try{  
  93.          int chr = 0;   
  94.          InputStream arquivoHelp = getClass().getResourceAsStream("/ajuda/Ajuda.Thomazini");  
  95.          StringBuffer stb = new StringBuffer();          
  96.          while ((chr = arquivoHelp.read())!= -1)  
  97.             stb.append((char)chr);  
  98.          return stb.toString();            
  99.       }catch (Exception e){  
  100.          alerta("Erro ao abrir o arquivo de ajuda!", formMaim);  
  101.       }   
  102.       return null;  
  103.    }    
  104.      
  105.     public AlteraFormulario alteraFormulario(){  
  106.         return alteraFormulario;  
  107.     }  
  108.       
  109.    public void alerta(String mensagem, Form frm){  
  110.       try{  
  111.          Image img = Image.createImage("/imagem/Duke.png");  
  112.          alerta = new Alert("Controle de Despesas", mensagem, img,null);     
  113.          alerta.setTicker(ticker);  
  114.          alerta.setTimeout(Alert.FOREVER);  
  115.          display.setCurrent(alerta, frm);  
  116.       }catch (Exception e){}        
  117.    }   
  118.      
  119. }  


Classe de manipulação de formulários.

  1. /* 
  2.  * AlteraFormulario.java 
  3.  * 
  4.  * 
  5.  * 
  6.  */  
  7.   
  8. package controleForm;  
  9.   
  10. import java.util.Stack;  
  11. import javax.microedition.lcdui.Display;  
  12. import javax.microedition.lcdui.Displayable;  
  13.   
  14. /** 
  15.  * 
  16.  * Esta classe tem como função alterar no display os formulários da aplicação,  
  17.  * quando e  dado um “new” e passado para ela o display do MIDLets e o formulário Principal,  
  18.  * quando for chamado o método “public void pushDisplayable(Displayable newDisplayable)”   
  19.  * e passado para ele a classe que tem o novo formulário com isso ela troca o formulário 
  20.  * principal com o que foi solicitado pelo usuário. 
  21.  *    Quando quiser voltar pro formulário principal e chamado o método 
  22.  * “ public void popDisplayable()” que retorna o formulário principal no display ou o formulario que esttiver 
  23.  *na vez de ser mostrado, ele trabalha em forma de pilha. 
  24.  *    
  25.  * 
  26.  * 
  27.  */  
  28.   
  29. public class AlteraFormulario extends Stack{  
  30.      
  31.    private Display      display = null;        
  32.    private Displayable mainForm = null;    
  33.    private static AlteraFormulario alteraFormulario = null;  
  34.      
  35.    private AlteraFormulario(Display display, Displayable mainForm){  
  36.       this.display = display;  
  37.       this.mainForm = mainForm;   
  38.    }     
  39.      
  40.    public static AlteraFormulario instancia(Display display, Displayable mainForm){  
  41.       if(alteraFormulario == null)  
  42.          alteraFormulario = new AlteraFormulario(display, mainForm);      
  43.      return alteraFormulario;  
  44.    }   
  45.      
  46.    public void pushForm(Displayable newForm){  
  47.       push(display.getCurrent());  
  48.       display.setCurrent(newForm);  
  49.    }   
  50.       
  51.    public void popForm(){  
  52.       if (empty() == false)  
  53.          display.setCurrent((Displayable) pop());  
  54.       else   
  55.          display.setCurrent(mainForm);  
  56.    }    
  57.      
  58. }  


Classe e a responsável por manipular os RMS .

  1. /* 
  2.  * ArmazenamentoPersistente.java 
  3.  * 
  4.  *
  5.  */  
  6.   
  7. package rms;  
  8.   
  9. import java.io.ByteArrayInputStream;  
  10. import java.io.ByteArrayOutputStream;  
  11. import java.io.DataInputStream;  
  12. import java.io.DataOutputStream;  
  13. import java.util.Vector;  
  14. import javax.microedition.rms.RecordEnumeration;  
  15. import javax.microedition.rms.RecordStore;  
  16.   
  17. /** 
  18.  * 
  19.  *   Esta classe e a responsável por manipular os RMS (Record Management System),  
  20.  * temos nela os seguintes métodos “public RecordStore openRecStore(String nome)”  
  21.  * que serve para abrir um RMS s ele já existir ele abre senão ele cria um armazém de  
  22.  * registros, temos também o método “public void closeRecStore(RecordStore rms)”  
  23.  * que serve para fechar um RMS, temos o método “public void deleteRecStore(String nome)”  
  24.  * que e o responsável por excluir um registro armazenado no RMS, e também o método  
  25.  * “public void gravarRegistro(RecordStore rms, String text)” que e o responsável por gravar  
  26.  * registros no RMS, temos outros métodos mas são semelhantes a estes citados que só muda os  
  27.  * parâmetros a serem passados a eles mas a funcionalidade e a mesma. 
  28.  * 
  29.  * 
  30.  * 
  31.  */  
  32.   
  33. public class ArmazenamentoPersistente {  
  34.       
  35.    private Vector                vetorGasto    = null;  
  36.    private ByteArrayInputStream  istrmBytes    = null;  
  37.    private DataInputStream       istrmDataType = null;  
  38.    private ByteArrayOutputStream ostrmBytes    = null;  
  39.    private DataOutputStream      ostrmDataType = null;    
  40.    private RecordEnumeration     numeroRms     = null;   
  41.    private OrdenaRms             ordenaRms     = null;  
  42.     
  43.    public ArmazenamentoPersistente() {  
  44.       vetorGasto = new Vector();      
  45.       ostrmBytes = new ByteArrayOutputStream();  
  46.       ostrmDataType = new DataOutputStream(ostrmBytes);   
  47.    }  
  48.           
  49.    public RecordEnumeration initEnumeration(RecordStore rms){             
  50.       try{  
  51.          if (rms.getNumRecords() > 0){  
  52.             ordenaRms = new OrdenaRms();            
  53.             numeroRms = rms.enumerateRecords(null, ordenaRms, false);  
  54.          }    
  55.       }catch (Exception e){System.out.println("Thomazini "+ e);}  
  56.       return numeroRms;  
  57.    }  
  58.      
  59.    public RecordStore openRecStore(String nome){  
  60.       try{        
  61.          return RecordStore.openRecordStore(nome, true);  
  62.       }catch (Exception e){return null;}  
  63.    }  
  64.      
  65.    public void closeRecStore(RecordStore rms){  
  66.       try{  
  67.          rms.closeRecordStore();  
  68.          ostrmBytes.close();  
  69.          ostrmDataType.close();  
  70.       }catch (Exception e){return;}           
  71.    }  
  72.     
  73.    public void deleteRecStore(String nome){  
  74.       try{  
  75.          RecordStore.deleteRecordStore(nome);  
  76.       }catch (Exception e){return;}  
  77.    }   
  78.      
  79.    public void gravarRegistro(RecordStore rms, String text){  
  80.       try{        
  81.          byte[] record;   
  82.          ostrmBytes.reset();  
  83.          ostrmDataType.writeUTF(text);  
  84.          ostrmDataType.flush();  
  85.          record = ostrmBytes.toByteArray();  
  86.          rms.addRecord(record, 0, record.length);            
  87.          ostrmBytes.reset();  
  88.       }catch (Exception e) {return;}        
  89.    }   
  90.      
  91.    public void gravarRegistro(RecordStore rms, String vDescricao, int vQnt, float vValor){  
  92.       int [] qnt = {vQnt};  
  93.       String[] descricao = {vDescricao};  
  94.       float[] valor = {vValor};  
  95.       gravarRms(rms, descricao,qnt,valor);  
  96.    }     
  97.      
  98.    private void gravarRms(RecordStore rms, String[] vDescricao,int[] vQnt, float[] vValor) {  
  99.       try {             
  100.          ostrmBytes.reset();      
  101.          byte[] record = null;        
  102.          for (int i = 0; i < vDescricao.length; i++){             
  103.             ostrmDataType.writeUTF(vDescricao[i]);  
  104.             ostrmDataType.writeInt(vQnt[i]);             
  105.             ostrmDataType.writeFloat(vValor[i]);  
  106.             ostrmDataType.flush();  
  107.             record = ostrmBytes.toByteArray();  
  108.             rms.addRecord(record, 0, record.length);              
  109.             ostrmBytes.reset();  
  110.          }  
  111.       }catch (Exception e) {return;}      
  112.    }      
  113.      
  114. }  


Classe para ordenar o RMS.

  1.    
  2.   
  3. /* 
  4.  * OrdenaRms.java 
  5.  * 
  6.  *
  7.  */  
  8.   
  9. package rms;  
  10.   
  11. import java.io.ByteArrayInputStream;  
  12. import java.io.DataInputStream;  
  13. import javax.microedition.rms.RecordComparator;  
  14.   
  15. /** 
  16.  *  
  17.  *   Esta e a classe responsável por fazer a ordenação dos dados dos registros,  
  18.  * ela contem os seguinte método  
  19.  * “public int compare(byte[] rec1, byte[] rec2)” que e o responsável por ordenar os dados informados   
  20.  * que no casso ordena em ordem alfabética, e temos também o método  
  21.  * “public void compareClose()” que e o responsável por finalizar o processo de ordenação. 
  22.  * 
  23.  *
  24.  * 
  25.  */  
  26.   
  27. public class OrdenaRms implements RecordComparator {  
  28.      
  29.    private byte[] record                  = null;    
  30.    private ByteArrayInputStream strmBytes = null;   
  31.    private DataInputStream strmDataType   = null;  
  32.       
  33.    public OrdenaRms() { }  
  34.      
  35.    public void compareClose(){  
  36.       try{  
  37.          if (strmBytes != null)  
  38.             strmBytes.close();  
  39.          if (strmDataType != null)  
  40.             strmDataType.close();  
  41.       }catch (Exception e){}  
  42.    }   
  43.      
  44.    public int compare(byte[] rec1, byte[] rec2){  
  45.       String valor1 = null, valor2 = null;  
  46.       try{        
  47.          int maxsize = Math.max(rec1.length, rec2.length);  
  48.          record = new byte[maxsize];        
  49.          strmBytes = new ByteArrayInputStream(rec1);  
  50.          strmDataType = new DataInputStream(strmBytes);        
  51.          valor1 = strmDataType.readUTF();        
  52.          strmBytes = new ByteArrayInputStream(rec2);  
  53.          strmDataType = new DataInputStream(strmBytes);       
  54.          valor2 = strmDataType.readUTF();        
  55.          int resultado = valor1.compareTo(valor2);  
  56.          if (resultado == 0)  
  57.             return RecordComparator.EQUIVALENT;  
  58.          else if (resultado < 0)  
  59.             return RecordComparator.PRECEDES;  
  60.          else  
  61.             return RecordComparator.FOLLOWS;  
  62.       }catch (Exception e){  
  63.          return RecordComparator.EQUIVALENT;  
  64.        }  
  65.    }    
  66. }  


Classe que será utilizada para cirar os objetos que serão manipulados no aplicativo.

  1. /* 
  2.  * ItemRms.java 
  3.  * 
  4.  *
  5.  */  
  6.   
  7. package rms;  
  8.   
  9. /** 
  10.  * 
  11.  *    Esta classe é a responsável por agrupar nela o descrição informada com o  
  12.  * ID da mesma armazenando os 2 em um objeto. Temos os seguintes métodos  
  13.  * “public void setText(String text)” que serve para trocar a descrição do item, temos também o método  
  14.  * “public String getText()” e o responsável para ler a descrição do item, temos também o método  
  15.  * “public int getRecordId()” que lê o numero do ID do item.. 
  16.  * 
  17.  *
  18.  * 
  19.  */   
  20.   
  21. public class ItemRms {  
  22.    private String texto;   
  23.    private int id;   
  24.    
  25.    public ItemRms(String texto, int id) {         
  26.       this.texto = texto;  
  27.       this.id = id;  
  28.    }  
  29.    public String getTexto(){  
  30.       return texto;  
  31.    }  
  32.      
  33.    public void setTexto(String texto){  
  34.       this.texto = texto;  
  35.    }    
  36.      
  37.    public int getId(){  
  38.       return id;  
  39.    }              
  40. }  


Classe Cadastro de Tipos de Gastos.

  1.    
  2.   
  3. /* 
  4.  * ReferenciaDespesas.java 
  5.  *
  6.  * 
  7.  */  
  8.   
  9. package form;  
  10.   
  11. import java.io.ByteArrayInputStream;  
  12. import java.io.ByteArrayOutputStream;  
  13. import java.io.DataInputStream;  
  14. import java.io.DataOutputStream;  
  15. import java.util.Vector;  
  16. import javax.microedition.lcdui.Alert;  
  17. import javax.microedition.lcdui.Choice;  
  18. import javax.microedition.lcdui.ChoiceGroup;  
  19. import javax.microedition.lcdui.Command;  
  20. import javax.microedition.lcdui.CommandListener;  
  21. import javax.microedition.lcdui.Displayable;  
  22. import javax.microedition.lcdui.Form;  
  23. import javax.microedition.lcdui.Item;  
  24. import javax.microedition.lcdui.ItemCommandListener;  
  25. import javax.microedition.lcdui.ItemStateListener;  
  26. import javax.microedition.lcdui.StringItem;  
  27. import javax.microedition.lcdui.TextField;  
  28. import javax.microedition.lcdui.Ticker;  
  29. import javax.microedition.rms.RecordEnumeration;  
  30. import javax.microedition.rms.RecordStore;  
  31. import midlet.ControledeGastos;  
  32. import rms.ArmazenamentoPersistente;  
  33. import rms.ItemRms;  
  34. import rms.OrdenaRms;  
  35.   
  36. /** 
  37.  * 
  38.  *    Esta e a classe que tem o formulário de Referência de gastos e nela que o usuário vai fazer o  
  39.  * cadastro de seus possíveis gastos, nela temos os seguintes métodos. 
  40.  * O método “protected void referencialistaVetor()” e o responsável por listar os dados que 
  41.  * estão no vetor e criar na telas os componentes que vão mostrar as referências cadastradas,  
  42.  * Temos também o método “private void referenciaOrdenaVetor(RecordStore rms)” este e o método que  
  43.  * lista o conteúdo do RMS e armazena dentro de um vetor para ficar mais fácil de manipular os dados,  
  44.  * temos o método “public void itemStateChanged(Item item)” que é onde nos pegamos os eventos dos  
  45.  * componentes (ChoiceGroup), temos o método “public void commandAction(Command c, Displayable d)”  
  46.  * que e onde pegamos os eventos do menu do aparelho e também o método  
  47.  * “public void commandAction(Command c, Item item)” que onde e pego o evento do botão. 
  48.  * 
  49.  *
  50.  * 
  51.  */  
  52.   
  53. public class ReferenciaDespesas extends Form implements ItemStateListener,   
  54.                                                         CommandListener,   
  55.                                                         ItemCommandListener {  
  56.    private Alert alertErro = null;  
  57.    private StringItem buttonGravar = null;  
  58.    private TextField tfDescricao = null;     
  59.    private Command commGravar    = null,   
  60.                      commExit    = null;                    
  61.    private Vector   vetorItem    = null;       
  62.    private ChoiceGroup cgItem    = null;      
  63.    private String REC_STORE_REFERENCIA_GASTO = null;    
  64.    private ByteArrayInputStream istrmBytes   = null;  
  65.    private DataInputStream istrmDataType     = null;    
  66.    private ByteArrayOutputStream ostrmBytes  = null;  
  67.    private DataOutputStream ostrmDataType    = null;     
  68.    private RecordEnumeration numeroRms  = null;   
  69.    private OrdenaRms ordenaRms          = null;   
  70.    private ControledeGastos frmControle = null;  
  71.    private RecordStore referenciaRms    = null;  
  72.    private ArmazenamentoPersistente referenciaGasto = null;        
  73.       
  74.       
  75.     public ReferenciaDespesas(String titulo,ControledeGastos frmControle, Ticker ticker) {  
  76.        super(titulo);  
  77.        this.frmControle = frmControle;  
  78.        vetorItem = new Vector();  
  79.        REC_STORE_REFERENCIA_GASTO = "rmsReferenciaGasto";  
  80.        referenciaRms =(referenciaGasto = new ArmazenamentoPersistente()).openRecStore(REC_STORE_REFERENCIA_GASTO);                 
  81.        buttonGravar = new StringItem("                              Gravar","", Item.BUTTON);  
  82.        buttonGravar.setDefaultCommand(commGravar = new Command("Gravar", Command.ITEM, 1));  
  83.        buttonGravar.setItemCommandListener(this);      
  84.        buttonGravar.setPreferredSize(235,10);          
  85.        setTicker(ticker);  
  86.        addCommand(commExit = new Command( "Sair", Command.EXIT, 1 ));          
  87.        append( tfDescricao = new TextField( "Descrição:","",80, TextField.ANY ));  
  88.        append( buttonGravar );   
  89.        append( cgItem = new ChoiceGroup( "", Choice.MULTIPLE ));  
  90.        setCommandListener(this);  
  91.        setItemStateListener(this);        
  92.        listarOrdenarRms( referenciaRms );    
  93.     }  
  94.       
  95.     private void listarOrdenarRms(RecordStore rms){  
  96.       try{  
  97.          referenciaOrdenaVetor(rms);  
  98.          referencialistaVetor();           
  99.       }catch (Exception e){  
  100.           msg("Ocorreu um erro na listagem dos registros armazenados!");       
  101.        }          
  102.    }   
  103.       
  104.    protected void referencialistaVetor(){  
  105.       try{  
  106.          for (int i = cgItem.size(); i > 0; i--)  
  107.             cgItem.delete(i - 1);  
  108.          ItemRms item;        
  109.          String texto;  
  110.          StringBuffer strb;  
  111.          for (int i = 0; i < vetorItem.size(); i++){  
  112.             item = (ItemRms) vetorItem.elementAt(i);        
  113.             texto = (item.getTexto());        
  114.             strb = new StringBuffer();  
  115.             strb.append(texto);       
  116.             cgItem.append(strb.toString(), null);  
  117.          }  
  118.       }catch (Exception e){  
  119.           msg("Erro ao listar os registros!");            
  120.        }  
  121.    }  
  122.      
  123.    private void referenciaOrdenaVetor(RecordStore rms){    
  124.       try{  
  125.          vetorItem.removeAllElements();  
  126.          byte[] recData = new byte[referenciaRms.getSize()];   
  127.          ByteArrayInputStream   istrmBytes = new ByteArrayInputStream(recData);  
  128.          DataInputStream   istrmDataType = new DataInputStream(istrmBytes);  
  129.          numeroRms = referenciaGasto.initEnumeration(rms);  
  130.          numeroRms.rebuild();  
  131.          while (numeroRms.hasNextElement()){          
  132.             istrmBytes.reset();         
  133.             int id = numeroRms.nextRecordId();  
  134.             rms.getRecord(id, recData, 0);            
  135.             ItemRms item = new ItemRms(istrmDataType.readUTF(), id);  
  136.             vetorItem.addElement(item);             
  137.          }  
  138.          istrmBytes.close();  
  139.          istrmDataType.close();  
  140.       }catch (Exception e){  
  141.           msg("Erro ao ordenar os registros!");   
  142.        }  
  143.    }  
  144.      
  145.    protected void gravar(){  
  146.       try{  
  147.       referenciaGasto.gravarRegistro(referenciaRms, tfDescricao.getString());  
  148.       tfDescricao.delete(0,tfDescricao.size());  
  149.       listarOrdenarRms(referenciaRms);  
  150.       }catch (Exception e){  
  151.           msg("Ocorreu uma falha na gravação do registro!");     
  152.        }  
  153.    }  
  154.      
  155.    public void itemStateChanged(Item item){  
  156.       ChoiceGroup cgGroup;     
  157.       cgGroup = (ChoiceGroup) item;  
  158.       boolean selected[] = new boolean[cgGroup.size()];  
  159.       cgGroup.getSelectedFlags(selected);    
  160.       for (int i = 0; i < cgGroup.size(); i++){  
  161.          if (selected[i]){          
  162.             ItemRms vItem = (ItemRms) vetorItem.elementAt(i);  
  163.             try{  
  164.                referenciaRms.deleteRecord(vItem.getId());  
  165.             }catch (Exception e){  
  166.                 msg("Erro ao excluir o registro!");     
  167.              }break;  
  168.          }  
  169.       }listarOrdenarRms(referenciaRms);  
  170.    }  
  171.      
  172.    public void commandAction(Command c, Displayable d){  
  173.       if (c == commExit){           
  174.          referenciaGasto.closeRecStore(referenciaRms);  
  175.          frmControle.alteraFormulario().popForm();  
  176.       }  
  177.    }  
  178.      
  179.    public void commandAction(Command c, Item item) {    
  180.       if (item == buttonGravar)  
  181.          if (tfDescricao.size() != 0){gravar();}                   
  182.    }  
  183.      
  184.    private void msg(String msg){  
  185.       frmControle.alerta(msg, this);      
  186.    }   
  187. }  


Cadastro de Gastos.
  1. /* 
  2.  * RegistroDespesas.java 
  3.  * 
  4.  * 
  5.  */  
  6.   
  7. package form;  
  8.   
  9. import java.io.ByteArrayInputStream;  
  10. import java.io.ByteArrayOutputStream;  
  11. import java.io.DataInputStream;  
  12. import java.io.DataOutputStream;  
  13. import java.util.Vector;  
  14. import javax.microedition.lcdui.Alert;  
  15. import javax.microedition.lcdui.Choice;  
  16. import javax.microedition.lcdui.ChoiceGroup;  
  17. import javax.microedition.lcdui.Command;  
  18. import javax.microedition.lcdui.CommandListener;  
  19. import javax.microedition.lcdui.Displayable;  
  20. import javax.microedition.lcdui.Form;  
  21. import javax.microedition.lcdui.Item;  
  22. import javax.microedition.lcdui.ItemCommandListener;  
  23. import javax.microedition.lcdui.ItemStateListener;  
  24. import javax.microedition.lcdui.StringItem;  
  25. import javax.microedition.lcdui.TextField;  
  26. import javax.microedition.lcdui.Ticker;  
  27. import javax.microedition.rms.RecordEnumeration;  
  28. import javax.microedition.rms.RecordStore;  
  29. import midlet.ControledeGastos;  
  30. import rms.ArmazenamentoPersistente;  
  31. import rms.ItemRms;  
  32. import rms.OrdenaRms;  
  33.   
  34. /** 
  35.  * 
  36.  *    Esta e a classe que tem o formulário de Controle de gastos e nela que o usuário vai fazer  
  37.  * o cadastro de seus gastos, nela temos os seguintes métodos. 
  38.  * O método “protected ChoiceGroup getcgReferencia()” que é o responsável por criar o componente  
  39.  * (ChoiceGroup) que vai conter os dados do RMS de Referência de gastos, temos também o método  
  40.  * “protected void cgReferenciaItem()”que é  o responsável por listas todos os registro que estão no  
  41.  * RMS Referência de gastos no componente (ChoiceGroup), e temos o método  
  42.  * “protected void despesasListarVetor()” que e o responsável por listar os dados que estão no vetor  
  43.  * e criar os componentes para exibição dos gastos cadastrados, e o método  
  44.  * “protected void despesasOrdenaVetor(RecordStore rms)” e o responsável por listar os dados do  
  45.  * RMS no vetor ele percorre todo o armazém de registro e grava dentro do vetor para ficar mais 
  46.  * melhor a manipulação destes dados, temos o método “public void itemStateChanged(Item item)” 
  47.  * que é onde nos pegamos os eventos dos  
  48.  * componentes (ChoiceGroup), temos o método “public void commandAction(Command c, Displayable d)”  
  49.  * que e onde pegamos os eventos do menu do aparelho e também o método  
  50.  * “public void commandAction(Command c, Item item)” que onde e pego o evento do botão. 
  51.  * 
  52.  *
  53.  * 
  54.  */  
  55.   
  56. public class RegistroDespesas extends Form implements ItemStateListener,   
  57.                                                       CommandListener,   
  58.                                                       ItemCommandListener{  
  59.    private Alert alertErro;     
  60.    private ChoiceGroup cgItem;   
  61.    private StringItem buttonGravar;    
  62.    private ControledeGastos frmControle;   
  63.    private ChoiceGroup cgReferenciaGasto;  
  64.    private TextField tfValor,tfQnt;   
  65.    private Command commExit, commGravar;  
  66.    private Vector vetorDespesa;   
  67.    private float total;  
  68.    private String REC_STORE_REFERENCIA_GASTO;    
  69.    private String REC_STORE_REGISTRO_DESPESAS;    
  70.    private ByteArrayInputStream istrmBytes;  
  71.    private DataInputStream istrmDataType;    
  72.    private ByteArrayOutputStream ostrmBytes;  
  73.    private DataOutputStream ostrmDataType;     
  74.    private RecordEnumeration numeroRms;   
  75.    private OrdenaRms ordenaRms;   
  76.    private RecordStore referenciaRms, registoDespesasRms;  
  77.    private ArmazenamentoPersistente referenciaGasto,registoDespesas;   
  78.      
  79.     public RegistroDespesas(String titulo,ControledeGastos frmControle, Ticker ticker) {  
  80.       super(titulo);  
  81.       this.frmControle = frmControle;      
  82.       setTicker(ticker);  
  83.       vetorDespesa = new Vector();  
  84.       REC_STORE_REFERENCIA_GASTO = "rmsReferenciaGasto";  
  85.       REC_STORE_REGISTRO_DESPESAS = "rmsRegistroGasto";      
  86.       referenciaRms = (referenciaGasto = new ArmazenamentoPersistente()).openRecStore(REC_STORE_REFERENCIA_GASTO);    
  87.       registoDespesasRms = (registoDespesas = new ArmazenamentoPersistente()).openRecStore(REC_STORE_REGISTRO_DESPESAS);       
  88.       buttonGravar = new StringItem("                              Gravar","",Item.BUTTON);  
  89.       buttonGravar.setDefaultCommand( commGravar = new Command("Gravar",Command.ITEM, 1) );  
  90.       buttonGravar.setItemCommandListener(this);      
  91.       buttonGravar.setPreferredSize(235,10);      
  92.       addCommand( commExit = new Command("Sair.",Command.EXIT, 1) );            
  93.       append( tfQnt = new TextField("Quantidade.:",""10, TextField.NUMERIC) );        
  94.       append( tfValor = new TextField("Valor Gasto:","",10, TextField.DECIMAL) );        
  95.       getcgReferencia();  
  96.       append(cgReferenciaGasto);              
  97.       append(buttonGravar);         
  98.       append(cgItem = new ChoiceGroup("", Choice.MULTIPLE));     
  99.       cgReferenciaItem();  
  100.       listarOrdenarRms(registoDespesasRms);   
  101.       setCommandListener(this);   
  102.       setItemStateListener(this);   
  103.     }  
  104.       
  105.     private void listarOrdenarRms(RecordStore rms){  
  106.       try{  
  107.          despesasOrdenaVetor(rms);  
  108.          despesasListarVetor();        
  109.       }catch (Exception e){  
  110.           msg("Ocorreu um erro na listagem dos registros armazenados!");  
  111.        }          
  112.    }   
  113.     
  114.    private void gravar(){  
  115.       try{            
  116.          registoDespesas.gravarRegistro(registoDespesasRms, cgReferenciaGasto.getString(cgReferenciaGasto.getSelectedIndex()),  
  117.                                         Integer.parseInt(tfQnt.getString()), Float.parseFloat(tfValor.getString()));             
  118.          tfValor.delete(0,tfValor.size());  
  119.          tfQnt.delete(0, tfQnt.size());             
  120.          cgReferenciaGasto.setSelectedIndex(0,true);  
  121.          listarOrdenarRms(registoDespesasRms);          
  122.       }catch (Exception e){  
  123.           msg("Ocorreu uma falha na gravação do registro!");  
  124.        }        
  125.   }  
  126.      
  127.    protected ChoiceGroup getcgReferencia() {  
  128.       if (cgReferenciaGasto == null) {                
  129.          cgReferenciaGasto = new ChoiceGroup("Referência..:", Choice.POPUP,new String[]{""},null);           
  130.       }return cgReferenciaGasto;        
  131.    }  
  132.      
  133.    protected void cgReferenciaItem(){    
  134.       try{       
  135.          byte[] recData = new byte[referenciaRms.getSize()];   
  136.          ByteArrayInputStream   istrmBytes = new ByteArrayInputStream(recData);  
  137.          DataInputStream   istrmDataType = new DataInputStream(istrmBytes);  
  138.          numeroRms = referenciaGasto.initEnumeration(referenciaRms);  
  139.          numeroRms.rebuild();  
  140.          while (numeroRms.hasNextElement()){          
  141.             istrmBytes.reset();         
  142.             int id = numeroRms.nextRecordId();  
  143.             referenciaRms.getRecord(id, recData, 0);            
  144.             ItemRms item = new ItemRms(istrmDataType.readUTF(), id);  
  145.             cgReferenciaGasto.append(item.getTexto(),null);                      
  146.          }  
  147.          istrmBytes.close();  
  148.          istrmDataType.close();  
  149.       }catch (Exception e){  
  150.           msg("Ocorreu um erro na listagem dos dados de referência!");  
  151.        }  
  152.    }   
  153.     
  154.    protected void despesasListarVetor(){  
  155.       try{      
  156.          for (int i = cgItem.size(); i > 0; i--)  
  157.             cgItem.delete(i - 1);  
  158.          ItemRms item;       
  159.          String text;  
  160.          StringBuffer strb;      
  161.          for (int i = 0; i < vetorDespesa.size(); i++){  
  162.             item = (ItemRms) vetorDespesa.elementAt(i);        
  163.             text = item.getTexto();        
  164.             strb = new StringBuffer();  
  165.             strb.append(text);        
  166.             cgItem.append(strb.toString(), null);  
  167.          }  
  168.       }catch (Exception e){  
  169.           msg("Erro ao listar os registros!");     
  170.        }  
  171.    }  
  172.      
  173.    protected void despesasOrdenaVetor(RecordStore rms) {     
  174.       try{  
  175.          total = 0;  
  176.          vetorDespesa.removeAllElements();  
  177.          byte[] recData = new byte[rms.getSize()];   
  178.          ByteArrayInputStream   istrmBytes = new ByteArrayInputStream(recData);  
  179.          DataInputStream   istrmDataType = new DataInputStream(istrmBytes);  
  180.          numeroRms = registoDespesas.initEnumeration(rms);   
  181.          numeroRms.rebuild();            
  182.          while (numeroRms.hasNextElement()){          
  183.             istrmBytes.reset();         
  184.             int id = numeroRms.nextRecordId();  
  185.             rms.getRecord(id, recData, 0);                
  186.             String vDesc = istrmDataType.readUTF();  
  187.             int vQuant = istrmDataType.readInt();              
  188.             float vValor = istrmDataType.readFloat();              
  189.             total = total + vValor;             
  190.             ItemRms item = new ItemRms (" " + vQuant + "-" + vDesc +"  R$: "+ vValor, id);  
  191.             vetorDespesa.addElement(item);  
  192.          }  
  193.         
  194.       }catch (Exception e){  
  195.           msg("Erro ao ordenar os registros!");     
  196.        }setTitle("Total R$: "+ total);  
  197.    }  
  198.      
  199.    public void itemStateChanged(Item item){  
  200.       if (item != cgReferenciaGasto){   
  201.          ChoiceGroup cgGroup;     
  202.          cgGroup = (ChoiceGroup) item;  
  203.          boolean selected[] = new boolean[cgGroup.size()];  
  204.          cgGroup.getSelectedFlags(selected);    
  205.          for (int i = 0; i < cgGroup.size(); i++){  
  206.             if (selected[i]){          
  207.                ItemRms vItem = (ItemRms) vetorDespesa.elementAt(i);  
  208.                try{  
  209.                   registoDespesasRms.deleteRecord(vItem.getId());  
  210.                }catch (Exception e){  
  211.                    msg("Erro ao excluir o registro!");  
  212.                 }break;  
  213.             }  
  214.          }listarOrdenarRms(registoDespesasRms);              
  215.       }  
  216.    }  
  217.    public void commandAction(Command c, Displayable s){  
  218.       if (c == commExit){  
  219.           referenciaGasto.closeRecStore(referenciaRms);  
  220.           registoDespesas.closeRecStore(registoDespesasRms);  
  221.          frmControle.alteraFormulario().popForm();  
  222.       }  
  223.    }      
  224.      
  225.    public void commandAction(Command c, Item item) {       
  226.       if (item == buttonGravar)  
  227.          if (cgReferenciaGasto.size() != 0){   
  228.             if (!validaCampoObrigatorio())  
  229.                gravar();  
  230.          }     
  231.    }  
  232.      
  233.    private boolean validaCampoObrigatorio(){  
  234.       boolean result;        
  235.       if(result = tfQnt.size() == 0){  
  236.          msg("Quantidade campo obrigatório");     
  237.       }else if (result = tfValor.size() == 0){  
  238.             msg("Valor campo obrigatório");  
  239.          }else if (result = cgReferenciaGasto.getString(cgReferenciaGasto.getSelectedIndex()) == "")  
  240.                msg("Referência campo obrigatório");   
  241.              
  242.       return result;      
  243.    }     
  244.   
  245.    private void msg(String msg){  
  246.       frmControle.alerta(msg, this);      
  247.    }    
  248.      
  249. }  


Classe para a entrada de login e senha para o servidor.
  1.    
  2.   
  3. /* 
  4.  * ComunicacaoServidorWeb.java 
  5.  * 
  6.   
  7.   
  8. package form;  
  9.   
  10. import conexao.ConexaoHttp;  
  11. import java.io.ByteArrayInputStream;  
  12. import java.io.DataInputStream;  
  13. import java.util.Vector;  
  14. import javax.microedition.io.HttpConnection;  
  15. import javax.microedition.lcdui.Command;  
  16. import javax.microedition.lcdui.CommandListener;  
  17. import javax.microedition.lcdui.Displayable;  
  18. import javax.microedition.lcdui.Form;  
  19. import javax.microedition.lcdui.Image;  
  20. import javax.microedition.lcdui.ImageItem;  
  21. import javax.microedition.lcdui.TextField;  
  22. import javax.microedition.lcdui.Ticker;  
  23. import javax.microedition.rms.RecordEnumeration;  
  24. import javax.microedition.rms.RecordStore;  
  25. import midlet.ControledeGastos;  
  26. import rms.ArmazenamentoPersistente;  
  27.   
  28. /** 
  29.  * 
  30.  *    Esta classe tem a função de solicitar ao usuário o Login e senha para fazer a conexão  
  31.  * com um servidor web, feito isso será disparado uma Thread que é pelo método “run()”  
  32.  * que e tratado os eventos,   O método “public void commandAction(Command c, Displayable s)” 
  33.  * é onde e pego os eventos dos componentes e passado para o método run() que processa o comando solicitado. 
  34.  * O método “private boolean enviaRMS(RecordStore rms)” e usado quando for pedido pra fazer  
  35.  * o envio dos dados para o servidor web e nele que é percorrido tudo o RMS (Record Management System)  
  36.  * e enviado para o servidor, quando os dados chegarem lá o responsável pelo processamento  
  37.  * e o Servlets que atualiza o banco de dados correspondente. 
  38.  * 
  39.  *
  40.  * 
  41.  * 
  42.  */  
  43.   
  44. public class ComunicacaoServidorWeb extends Form implements CommandListener, Runnable {  
  45.       
  46.    private ControledeGastos frmLogin = null;  
  47.    private Command commVoltar = null,  
  48.                    commLogin  = null,   
  49.                    commEnviar = null;  
  50.    private TextField tfLogin  = null,   
  51.                      tfSenha  = null,   
  52.                      tfUrl    = null;  
  53.    private RecordEnumeration numeroRms = null;   
  54.    private ArmazenamentoPersistente registoDespesas = null;      
  55.    private Thread commThread   = null;  
  56.    private HttpConnection http = null;  
  57.    private Command commCaptura = null;  
  58.    private ConexaoHttp conexaoServer = null;  
  59.    private String REC_STORE_REGISTRO_DESPESAS = null;  
  60.    private RecordStore registoDespesasRms     = null;  
  61.       
  62.    public ComunicacaoServidorWeb(String titulo, ControledeGastos frmLogin, Ticker ticker) {  
  63.       super(titulo);  
  64.       this.frmLogin = frmLogin;  
  65.       setTicker(ticker);  
  66.       REC_STORE_REGISTRO_DESPESAS = "rmsRegistroGasto";  
  67.       registoDespesasRms = (registoDespesas = new ArmazenamentoPersistente()).openRecStore(REC_STORE_REGISTRO_DESPESAS);        
  68.          
  69.       append(tfUrl = new TextField("URL","http://localhost:8080/Servlet/GetNpostServlet",200, TextField.URL));  
  70.       append(tfLogin = new TextField("Usuário""",20, TextField.ANY));  
  71.       append(tfSenha = new TextField("Senha""",20, TextField.PASSWORD));       
  72.       addCommand(commVoltar = new Command("Sair",Command.EXIT,1));  
  73.       addCommand(commLogin = new Command("Acessar",Command.OK,1));  
  74.          
  75.       try{  
  76.          Image image = Image.createImage("/imagem/jug_patch.gif");  
  77.          append(new ImageItem(null,image,ImageItem.LAYOUT_CENTER,null));  
  78.       }catch (Exception e) {}            
  79.       setCommandListener(this);  
  80.    }  
  81.      
  82.     public void commandAction(Command c, Displayable s){  
  83.       synchronized (this) {  
  84.          if (commThread != null) {return;}  
  85.          commCaptura = c;  
  86.          commThread = new Thread(this);  
  87.          commThread.start();  
  88.       }      
  89.    }  
  90.       
  91.    public void run() {          
  92.       if (commCaptura == commVoltar) {  
  93.          frmLogin.alteraFormulario().popForm();     
  94.       } else if (commCaptura == commLogin) {                       
  95.            try{  
  96.              conexaoServer = new ConexaoHttp(tfUrl.getString());   
  97.              if (conexaoServer.processoRmsPOST(("status=login"+  
  98.                                                 "&login=" + tfLogin.getString()+   
  99.                                                 "&senha=" + tfSenha.getString()).getBytes())){           
  100.                  if (conexaoServer.retornoConexao().equals(""))   
  101.                     msg("Usuário/Senha Inválido(s)");  
  102.                  else{  
  103.                      if(commEnviar == null)                       
  104.                         addCommand(commEnviar = new Command("Enviar",Command.OK,1));   
  105.                      msg("Seja bem vindo Sr.(a): " + conexaoServer.retornoConexao());                      
  106.                  }  
  107.               }else msg("Falha na autenticação do Login!");  
  108.            }finally{conexaoServer = null;}  
  109.         }else if (commCaptura == commEnviar){  
  110.             try{   
  111.                conexaoServer = new ConexaoHttp(tfUrl.getString());   
  112.                enviaRMS(registoDespesasRms);                 
  113.            }finally{  
  114.                removeCommand(commEnviar);  
  115.                conexaoServer = null;  
  116.             }  
  117.         }           
  118.        synchronized (this) {commThread = null;}  
  119.    }  
  120.      
  121.    private void enviaRMS(RecordStore rms){   
  122.       try{          
  123.          byte[] recData = new byte[rms.getSize()];   
  124.          ByteArrayInputStream   istrmBytes = new ByteArrayInputStream(recData);  
  125.          DataInputStream   istrmDataType = new DataInputStream(istrmBytes);  
  126.          numeroRms = registoDespesas.initEnumeration(rms);   
  127.          numeroRms.rebuild();            
  128.          try{          
  129.             while (numeroRms.hasNextElement()){          
  130.                istrmBytes.reset();         
  131.                int id = numeroRms.nextRecordId();              
  132.                rms.getRecord(id, recData, 0);   
  133.                conexaoServer.processoRmsPOST(("status="+conexaoServer.retornoConexao()+  
  134.                                              "&desc="+String.valueOf(istrmDataType.readUTF())+  
  135.                                              "&qnt="+String.valueOf(istrmDataType.readInt())+  
  136.                                              "&valor="+String.valueOf(istrmDataType.readFloat())+  
  137.                                              "&id="+String.valueOf(id)).getBytes());                                          
  138.            }            
  139.            msg("Transferência efetuada com sucesso!");  
  140.         }finally {  
  141.            istrmBytes.close();  
  142.            istrmDataType.close();   
  143.         }      
  144.      }catch (Exception e){  
  145.         msg("Problemas no envio do arquivo!");        
  146.       }  
  147.    }  
  148.     
  149.    private void msg(String msg){  
  150.       frmLogin.alerta(msg, this);      
  151.    }  
  152.      
  153. }  


Classe que faz a conexão com o servidor.

  1. /* 
  2.  * ConexaoHttp.java 
  3.  * 
  4.  *
  5.  * 
  6.  */  
  7.   
  8. package conexao;  
  9.   
  10. import java.io.ByteArrayOutputStream;  
  11. import java.io.IOException;  
  12. import java.io.InputStream;  
  13. import java.io.OutputStream;  
  14. import javax.microedition.io.Connector;  
  15. import javax.microedition.io.HttpConnection;  
  16.   
  17. /** 
  18.  * 
  19.  *    Esta classe tem como função fazer a conexão com o servidor web, é por ela que é enviado as solicitações  
  20.  * de login e também os dados do RMS. 
  21.  * O metodo “public boolean processoRmsPOST(byte[] dados)”  
  22.  * que é o responsável por fazer toda a parte de solicitações com o servidor, como: enviar os dados do RMS para o servidor web e fazer login e o método  
  23.  * “private boolean processServerResponse(HttpConnection  httpConexao, InputStream dados)”   
  24.  * ele que processa o retorno do servidor se tiver alguma informação vindo do servidor para o  
  25.  * aparelho é nele que é tratado. 
  26.  * 
  27.  * 
  28.  * 
  29.  */  
  30.   
  31. public class ConexaoHttp {  
  32.      
  33.    private String url    = null;  
  34.    private String result = null;  
  35.       
  36.    public ConexaoHttp(String url){  
  37.       this.url = url;  
  38.    }  
  39.      
  40.    public boolean processoRmsPOST(byte[] dados)  {      
  41.       HttpConnection httpConexao = null;  
  42.       OutputStream oStrm = null;  
  43.       InputStream iStrm = null;      
  44.       boolean valorRetorno = false;            
  45.       try{          
  46.          try{  
  47.        httpConexao = (HttpConnection)Connector.open(this.url);  
  48.        httpConexao.setRequestMethod(HttpConnection.POST);   
  49.             httpConexao.setRequestProperty("Content-Type""application/x-www-form-urlencoded");//Esta linha e obrigatoria para o metodo POS, isso indica que os dados estão indo separados da URL.            
  50.             oStrm = httpConexao.openOutputStream();  
  51.        oStrm.write(dados);//        
  52.        iStrm = httpConexao.openInputStream();  
  53.        valorRetorno =  processServerResponse(httpConexao, iStrm);  
  54.     }finally{  
  55.         if (iStrm != null) iStrm.close();  
  56.         if (oStrm != null)   oStrm.close();  
  57.              if (httpConexao != null) httpConexao.close();  
  58.      }if (valorRetorno == false){}  
  59.       }catch(Exception e){}  
  60.       return valorRetorno;        
  61.    }  
  62.      
  63.    private boolean processServerResponse(HttpConnection  httpConexao, InputStream dados) throws IOException {  
  64.        result = "";   
  65.        if ( httpConexao.getResponseCode() == HttpConnection.HTTP_OK ) {  
  66.          String urlNew = httpConexao.getHeaderField("Custom-newURL");           
  67.          if (urlNew != null)   
  68.             this.url = urlNew;  
  69.          int length = (int) httpConexao.getLength();  
  70.        String str = "";            
  71.        if (length != -1) {          
  72.           byte servletData[] = new byte[length];                
  73.           dados.read(servletData);  
  74.                str = new String(servletData);    
  75.        }else{  
  76.            ByteArrayOutputStream bStrm = new ByteArrayOutputStream();//isso serve para que quando tiver um retorno muito grande ele vai lendo e armazenando em uma array de bytes.         
  77.       int posicao = 0;  
  78.       while ((posicao = dados.read()) != -1) {  
  79.          bStrm.write(posicao);  
  80.          str = new String(bStrm.toByteArray());  
  81.          bStrm.close();  
  82.                 }  
  83.         }result = str;  
  84.          return true;           
  85.       }else return false;  
  86.    }  
  87.      
  88.    public String retornoConexao(){   
  89.       return result;  
  90.    }  
  91. } ]
  92.  É isso ai galera espero que tenham gostado e brevemente teremos mais. Até a próxima! De seu sempre amigo Bruno Rafael.

Comentários

Postagens mais visitadas deste blog

Algorítimo Para Validar Cpf Segundo Receita Federal em Java

Executar Audio em Java Swing

Gerenciamento de projetos: Introdução, Experiência e Estudo - Parte I