GPS, LBS e J2ME

// classes de uso do j2me
 import javax.microedition.midlet.*;
 import javax.microedition.lcdui.*;
 import javax.microedition.location.*;
 import LandmarkEditor;
 
 public class locationMidlet extends Midlet implements CommandListener {
     private Form form = null;
     private static Display display = null;
     // criação dos comandos
     private Command cmdExit;
     private Command cmdPesquisar;
     private Command cmdEditorPOI;
     // campos de latitude, longitude, altura e método usado
     private String lat = "", long = "", alt = "", meth = "";
     // provedor de locazação
     private LocationProvider provedor = null;
     // criterios p/ localização
     private Criteria cr = null;
     // referencia ao Editor de Marcos 
     private LandmarkEditor editorPOI = null;
     // permite saber se o aplicativo iniciou
     boolean inicializado = false;
     // itens do formulário dos informações
     private StringItem siLocalidade;
     private StringItem ErroMsg;
     private StringItem lat;
     private StringItem long;
     private StringItem alt;
     private StringItem meth;
     private static locationMidlet INSTANCIA = null;
     public Alert alert = null;

     private Form myForm;
     private boolean isInitialized;
     private boolean splashIsShown;


     // Main Location MIDlet
     public locationMidlet (){
        if( display == null ){
           // 1ª chamada do MIDlet
           initMIDlet();
        }

          display = Display.getDisplay(this);
          // criação do formulário com titulo
          form = new Form("LBS");
          // subtitulo
          form.append(new StringItem(null, "Localização!"));
          // criação dos comandos
          cmdExit = new Command("Sair", Command.EXIT, 0);
          cmdPesquisar = new Command("Pesquisar", Command.SCREEN, 1);
          cmdEditorPOI = new Command("Editor", Command.STOP, 2);
          // adiciona os comandos ao formulário
          form.addCommand(cmdExit); 
          form.addCommand(cmdPesquisar); 
          form.addCommand(cmdEditorPOI);
          // gerenciador de comandos 
          form.setCommandListener(this);
          editorPOI = new LandmarkEditor(this, data);
          criarProvedor();
          INSTANCIA = this;
     }

     // padrão Singleton p/ o método getInstance
     public static locationMidlet getInstance() {
          if (INSTANCIA == null) {
             INSTANCIA = new locationMidlet();
          }
          return INSTANCIA;
     }

     protected void startApp() throws MIDletStateChangeException{
          if ((display.getCurrent() == null) || (!inicializado)) {
          display.setCurrent(form);

          // amostrará o resultado da consulta do servlet LBS 
          siLocalidade = new StringItem("", "");
          ErroMsg = new String("");
          lat = new String("");
          long = new String("");
          alt = new String("");
          meth = new String("");

          display.setCurrent(form);

          thread tGetLocation = new thread(){
             public void run(){
                while(!splashIsShown){
                  Thread.yield();
                }

                doTimeConsumingInit();
        
                while(true){
                  // loop           
                  Thread.yield();
                }

                try{
	   // obtêm uma instância da classe Location
                   LocationProvider provedor=LocationProvider.getInstance(cr);
                   // pega a localização com tempo limite de 60s
                   Location loc=provedor.getLocation(60);
                }
                catch(LocationException e){
                   Alert alert = new Alert("Information", "Dados de localização inválidos", null, AlertType.INFO);
                   display.setCurrent(alert);                
                }
                catch(InterruptedException e){
                   Alert alert = new Alert("Information", "Parada inexperada", null, AlertType.INFO);
                   display.setCurrent(alert);
                }
             }
          }; 

         try {
             tGetLocation.start();
             tGetLocation.join();
             f.append(found(loc)+"location");
             // obtêm uma instancia um QualifiedCoordinates que representa as coordenadas 
             QualifiedCoordinates qc=loc.getQualifiedCoordinates();
             // uso das informações de coordenadas, vincula (exibição) ao formulario (display)
             // Caso haja coordenadas de localização
             coordenadas();
         } 
         catch(Exception e) {
            // tratamento de erro, 
            Alert alert = new Alert("Information", "Dados de localização invalidos", null, AlertType.INFO);
            display.setCurrent(alert);
         }
     }

     // passa o objeto de exibição (Display) do MIDlet e passa a proxima tela depois da exibição do splash screen

     private void initMIDlet(){
        Thread splashScreen = new Thread(new SplashScreenTest());
        splashScreen.start();
        
        Thread myGameThread = new Thread(this);
        myGameThread.start();       
    }

    private void doTimeConsumingInit(){ 
        // Just mimic some lengthy initialization for 10 secs
        long endTime= System.currentTimeMillis()+10000;
        while(System.currentTimeMillis()<endTime ){}
        
        // init the game's main Displyable (here a Form)
        myForm = new Form("Game Started!");
        myForm.addCommand(exitCommand);
        myForm.setCommandListener(this);
        isInitialized=true;
        display.setCurrent(myForm);
        
    }

    public class SplashScreen implements Runnable{
        private SplashCanvas splashCanvas;
        
        public void run(){
            splashCanvas = new SplashCanvas ();      
            display.setCurrent(splashCanvas);
            splashCanvas.repaint();
            splashCanvas.serviceRepaints();
            while(!isInitialized){
                try{
                    Thread.yield();
                }catch(Exception e){}
            }
        }

    }
    
    public class SplashCanvas extends Canvas {
            protected void paint(Graphics g){
            g.drawString("Show splash screen", 15, 60, Graphics.BOTTOM| Graphics.LEFT );
            g.drawString("image here!", 15, 75, Graphics.BOTTOM| Graphics.LEFT );
            splashIsShown=true;
        }
    }

     public static Display getDisplay(){
         return display;
     }

     // função de pausa orbigatoria do MIDlet
     protected void pauseApp(){
        Alert alert = new Alert("Information", "App em pausa", null, AlertType.INFO);
        display.setCurrent(alert);
        initialized = true;
     }

     // função orbigatoria do midlet (saida) 
     protected void destroyApp(boolean unconditional) throws MIDletStateChangeException{} 

     // gerenciador de ação (comando)
     public void commandAction(Command cmd, Displayable s) {
         if (cmd == cmdExit){
             destroyApp(true);
             notifyDestroyed();
         }
 
         else if (cmd == cmdPesquisar){
             PesquisarGet();
         }

         else if (cmd == cmdEditorPOI){
            if (coord != null){
               editorPOI.showEditor(coord, LandmarkEditor.MODE_ADDNEW);
            }
            else{
                Alert alert = new Alert("Information", "Dados de localização não são válidos", null, AlertType.INFO);
                display.setCurrent(alert);
            }
        } 
     }

     // Tela de apresentação (Splash Screen)

     public void showSplashScreen(Display d, Displayable next){
        Image logo = null;
   
         try {
            // res é a pasta padrão de imagens em um projeto de um MIDlet seguido do nome da imagem
           logo = Image.createImage("/res/GUJ.jpg");
         }
         catch(IOException e){}
    
         Alert a = new Alert("Time Tracker", "Elias Franco Lopes.", logo, null); 
         a.setTimeout(Alert.FOREVER);
         display.setCurrent(a, next);
     }

     // Inicializa o Provedor de Localização (LocationProvider)
     protect void criarProvedor() {
          if (ConfigurationProvider.isLocationApiSupported()){
             ConfigurationProvider.getInstance().autoSearch(this);
          }
          else{
             Alert alert = new Alert("Information", "Dispositivo não suporta a API Location", null, AlertType.INFO);
             // atualiza o display
             display.setCurrent(alert);
             destroyApp(false);
             notifyDestroyed();
        }

        ConfigurationProvider config = ConfigurationProvider.getInstance();
        provedor = config.getSelectedProvider();

        if (provedor == null) {
             Alert alert = new Alert("Information", "MIDLet não pode funcionar sem um provedor de localização", null, AlertType.INFO);
             // atualiza o display
             display.setCurrent(alert);
             destroyApp(false);
             notifyDestroyed();
          }

        if (provedor != null){
              provedor.setLocationListener(this, intervalo, timeout, maxage);
        }

        if (provedor == null) {
            // obtêm uma instancia da classe criteria
            cr = new Criteria();
            // Precisão de 1000m horizontalmente e verticalmente
            cr.setHorizontalAccuracy(100);
            cr.setVerticalAccuracy(100);
            // ajusta o nível de consumo de potência do aparelho p/ realizar a localização (nível alto p/ melhor localização)
            c.setPreferredPowerConsumption(Criteria.POWER_USAGE_HIGH);
       
             thread tGetLocation = new thread(){ 
                 public void run(){ 
                    try{
                       // obtêm uma instância da classe Location 
                       provedor = LocationProvider.getInstance(cr);
                       // pega a localização com tempo limite de 60s 
                       Location loc=provedor.getLocation(60); 
                    } 
                    catch(LocationException e){ 
                       Alert alert = new Alert("Information", "Não é possível criar o LocationProvider para criteria", null, AlertType.INFO);
                       display.setCurrent(alert);
                    } 
                    catch(InterruptedException e){ 
                       Alert alert = new Alert("Information", "Parada inexperada", null, AlertType.INFO);
                       display.setCurrent(alert);
                    } 
                 } 
             }; 
        } 
     }

     public static void coordenadas(){
        if((qc != null) || (loc.isValid())) {
           AddressInfo address = loc.getAddressInfo();
           // obtêm a latitude
           lat = Coordinates.convert(qc.getLatitude(), Coordinates.DD_MM_SS), "");
           // obtêm a longitude
           long = Coordinates.convert(qc.getLongitude(), Coordinates.DD_MM_SS), "");
           // obtêm a altura
           alt = Coordinates.convert(qc.getAltitude(), Coordinates.DD_MM_SS), "");
           String locate = c.convert(alt,1);
           // obtêm a método de localização
           meth = location.getLocationMethod();

           if((loc.getLocationMethod() & loc.MTE_SATELLITE) !=0){
              f.append(?Method = Satellite?);
           }

           // exibe a altura
           f.append("Altura: "+lat);
           // exibe a latitude
           f.append("Latitude: "+long);
           // exibe a longitude
           f.append("Longitude: "+alt);
           // exibe o método
           f.append("Método: "+meth);
           // exibe a localizadde
           f.append(siLocalidade);
           // atualiza o display
           display.setCurrent(f);
        }
        else{
           // caso a localização ou as coordenadas não é valida.
           String msg = location.getExtraInfo(?application/X-jsr179-location-nmea?);
           f.append("Localização não válida: "+msg);
           loc.getExtraInfo(String mimetype);
           getExtraInfo(?application/X-jsr179-location-nmea?);
           getExtraInfo(?text/plain?);
           f.append(?loc.getExtraInfo("text/plain"));
        }
        qc = loc.getQualifiedCoordinates();
     }

     // Exibe o estado do provedor de localização
     public static void showProvStatus(){
        Gauge indicador = new Gauge(null, false, 50, 1);
        indicador.setValue(Gauge.CONTINUOUS_RUNNING);

        Alert alert = new Alert("Information", "Espere, procurando por dados de localização....", null, AlertType.INFO);
        alert.setIndicator(indicador);
        display().setCurrent(alert);
    }

     // Acesso ao Servlet Usando metodo Get
     public void PesquisarGet() throws IOException {
        // Criação dos elementos HttpConnection e InputStream utilizados numa conexão do tipo GET
        HttpConnection hc = null;
        InputStream is = null;
        boolean ret = false;

        thread tConnection = new thread(){
           public void run(){
              // Inicializa uma conexão
              hc = (HttpConnection) Connector.open(url);
              hc.setRequestMethod(HttpConnection.GET);
           }
        };
 
        // Definição de URL que enviara os dados (coordenadas) para a pesquisa
        String url = "http://ENDEREÇO_DO_SERVLET:8080/" + "?" + "latitude=" + lat + "&longitude=" + long
 
        try{
           // Inicializa uma conexão
           AlertType.INFO.playSound(m_Display);
           tConnection.start();
           tConnection.join();
           // Inicia o InputStream para troca de mensagens
           is = hc.openInputStream();
           ret = processResp(hc, is) 	    
         }
 
         finally{
            if (is != null)
               // Finaliza conexão
               is.close();   
               if (hc != null)
                  hc.close();
            }
            if(ret == false)
               showAlert(erroMsg);
            }
 
     // Processa uma reposta do Servlet
     public boolean processaResp(HttpConnection hc, InputStream is) throws IOException { 	       
        erroMsg = null; 
        // se conexão realizada e resposta foi OK, calcula o tamanho da resposta (resultado)
        if(hc.getResponseCode() == HttpConnection.HTTP_OK){
           int length = (int) hc.getLength();
           string str;
              
           if(length != -1){
              byte servletData[] = new Byte[lenght];
              // recebe resposta do servlet e depois guarda em str
              is.read(servletData);
              str = new string(servletData);
           }
           else{  
              ByteArrayOutputstream bos = new ByteArrayOutputstream();
              int ch;
              while(ch = is.read() != -1)
                 bos.write(ch);
             
              str = new String(bos.toByteArray());
              bos.close()
           }
           // amostra o resultado (resposta do servlet) no display   
           siLocalidade.setText(str);
           return true;
        }
        else{
           erroMsg = new String(hc.getResponseMessage());
           showAlerta(erroMsg);
           return false;
        }

        // exibe um alerta
        private void showAlerta(String msg){
           alert = new Alert("Error", msg, null, AlertType.ERROR);
           alert.setTimeout(3000); // 3 seg
           display.setCurrent(alert, this);
           return null;
        }

} // fim de locationMidlet

import java.util.*;
import javax.microedition.lcdui.*;

public class SplashScreen extends Canvas {
    private Display display;
    private Displayable next;
    private Timer timer = new Timer();

    public SplashScreen(Display display, Displayable next){
        this.display = display;
        this.next = next;
        display.setCurrent(this);
    }

    protected void keyPressed(int keyCode){
        dismiss();
    }

    protected void paint(Graphics g){
       g.setColor(255, 0, 0);
       g.fillRect(0, 0, getWidth(), getHeight(  ));
       g.setColor(255, 255, 255);
       g.drawString("Hello World!", 0, 0, g.TOP | g.LEFT);
    }

    protected void pointerPressed(int x, int y){
        dismiss();
    }

    protected void showNotify(){
        timer.schedule(new CountDown(), 5000);
    }

    private void dismiss(){
        timer.cancel();
        display.setCurrent(next);
    }

    private class CountDown extends TimerTask {
        public void run(){
            dismiss();
        }
    }
}

import java.io.IOException;
     import java.util.Enumeration;
     import javax.microedition.lcdui.*;
     import javax.microedition.location.*;
     import ControleMarcos;

     Editor de Marcos/pontos de interesse (landmark)
     class LandmarkEditor extends Form implements CommandListener{
     // campos referentes aos marcos. (*) = campos obrigatórios
     private TextField nameField;
     private TextField descField;

     // campos do AddressInfo
     private TextField countryField;
     private TextField stateField;
     private TextField cityField;
     private TextField streetField;
     private TextField buildingNameField;
     // constantes
     public static final int MODE_UPDATE = 0;
     public static final int MODE_ADDNEW = 1;
     private QualifiedCoordinates coord = null;
     private Displayable route = null;
     private TouristData data = null;
     // informação de coordenadas
     private StringItem lat;
     private StringItem lon;
     private StringItem alt;
     // lista do marco selecionado
     private List list;
     private Command saveNewCmd;
     private Command saveUpdatedCmd;
     private Command updateCmd;
     private Command removeCmd;
     private Command listCmd;
     private Command routeCmd;

     public LandmarkEditor(Displayable route, TouristData data){
        super("Editor de Marcos");

        nameField = new TextField("Name (*):", "", 20, TextField.ANY);
        descField = new TextField("Description (*):", "", 40, TextField.ANY);
        countryField = new TextField("Country:", "", 20, TextField.ANY);
        stateField = new TextField("State:", "", 20, TextField.ANY);
        cityField = new TextField("City:", "", 20, TextField.ANY);
        streetField = new TextField("Street:", "", 20, TextField.ANY);
        buildingNameField = new TextField("Building name (*):", "", 20, TextField.ANY);
        lat = new StringItem("Lat:", "");
        lon = new StringItem("Lon:", "");
        alt = new StringItem("Alt:", "");
        list = new List("Landmarks:", List.EXCLUSIVE);
        cmdSaveNew = new Command("Savar", Command.OK, 1);
        cmdSaveUpdated = new Command("Savar", Command.OK, 1);
        cmdUpdate = new Command("Atualizar", Command.OK, 1);
        cmdRemove = new Command("Remover", Command.OK, 1);
        cmdList = new Command("Listar", Command.OK, 1);
        cmdRoute = new Command("Rota", Command.BACK, 1);

        this.route = route;
        this.data = data;

        // comandos do editor de marcos
        addCommand(routeCmd);
        addCommand(listCmd);
        setCommandListener(this);

        // comandos da lista de marcos 
        list.addCommand(routeCmd);
        list.setCommandListener(this);
    }

    // inicializa campos e exibe o editor de marcos
    public void showEditor(QualifiedCoordinates newCoord, int mode){
        this.coord = newCoord;

        // inicializa as coordenadas
        lat.setText(formatDouble(newCoord.getLatitude(), 3));
        lon.setText(formatDouble(newCoord.getLongitude(), 3));
        alt.setText(formatDouble(newCoord.getAltitude(), 1));

        // inicializa campos
        nameField.setString("");
        descField.setString("");
        countryField.setString("");
        stateField.setString("");
        cityField.setString("");
        streetField.setString("");
        buildingNameField.setString("");

        deleteAll();
        append(nameField);
        append(descField);
        append(countryField);
        append(stateField);
        append(cityField);
        append(streetField);
        append(buildingNameField);

        append(lat);
        append(lon);
        append(alt);

        // Atualiza existente marco
        if (mode == MODE_UPDATE){
            Landmark lm = ControleMarcos.getInstance().localizarProxMarco(newCoord);

            if (lm != null){
                nameField.setString(lm.getName());
                descField.setString(lm.getDescription());

                AddressInfo info = lm.getAddressInfo();
                if (info != null){
                    countryField.setString(info.getField(AddressInfo.COUNTRY));
                    stateField.setString(info.getField(AddressInfo.STATE));
                    cityField.setString(info.getField(AddressInfo.CITY));
                    streetField.setString(info.getField(AddressInfo.STREET));
                    buildingNameField.setString(info.getField(AddressInfo.BUILDING_NAME));
                }
            }

            removeCommand(updateCmd);
            removeCommand(saveNewCmd);
            addCommand(saveUpdatedCmd);
            addCommand(listCmd);
        }
        // adiciona novo marco ao LandmarkStore.
        else if (mode == MODE_ADDNEW){
            removeCommand(updateCmd);
            removeCommand(saveUpdatedCmd);
            addCommand(saveNewCmd);
            addCommand(listCmd);
        }
        display.setCurrent(this);
    }

    public void showList(){
        list.deleteAll();
        Landmark lm = null;
        Enumeration enuMarcos = ControleMarcoss.getInstance().getLandMarks();

        // verifica se o marco existe no landmarkstore.
        if (landmarks != null){
            while (enuMarcos.hasMoreElements()){
                lm = ((Landmark) enuMarcos.nextElement());
                list.append(lm.getName(), null);
            }

            list.addCommand(cmdUpdate);
            list.addCommand(cmdRemove);
        }
        // marco ñ localizado (lista em branco)
        else{
            list.removeCommand(cmdUpdate);
            list.removeCommand(cmdRemove);
        }
        display.setCurrent(list);
    }

    // verefica se os campos obrigatórios foram preenchidos
    private String checaCampos(){
        if (nameField.getString().equals("")){
            return "Nome";
        }
        else if (nameField.getString().equals("")){
            return "Descrição";
        }
        else if (buildingNameField.getString().equals("")){
            return "Local";
        }
        return null;
    }

     private Landmark gerarMarco(){
        String field = checaCampos();
        if (field != null){
           erroMsg = new String("Valor do campo obrigatório ("+ field + ") está errado");
           showAlerta(erroMsg);

           /*
           Alert alert = new Alert("Error", "Valor do campo obrigatório ("+ field + ") está errado.", null, AlertType.ERROR);
              alert.setTimeout(3000); // 3 secs
              display().setCurrent(alert, this);
              return null;
           }
           */

        AddressInfo info = new AddressInfo();
        info.setField(AddressInfo.COUNTRY, countryField.getString());
        info.setField(AddressInfo.STATE, stateField.getString());
        info.setField(AddressInfo.CITY, cityField.getString());
        info.setField(AddressInfo.STREET, streetField.getString());
        info.setField(AddressInfo.BUILDING_NAME, buildingNameField.getString());

        Landmark lm = new Landmark(nameField.getString(), descField.getString(), coord, info);
        return lm;
    }

        public void commandAction(Command command, Displayable displayable){
        Landmark landmark = null;

        // adiciona novo marco ao LandmarkStore
        if (command == cmdSaveNew){
            landmark = gerarMarco();
            if (landmark != null){
                try{
                    ControleMarcos.getInstance().addMarco(landmark);
                    data.createProximityListener(coord);
                }
                catch (IOException e)
                {
                    Alert alert = new Alert("Error", "Erro de Entrada/Saída", null, AlertType.ERROR);
                    display().setCurrent(alert);
                }
                // novo marco avaliado na lista
                showList();
            }
        }
        // atualiza o marco
        else if (command == cmdSaveUpdated){
            landmark = gerarMarco();
            if (landmark != null){
                try{
                    ControleMarcos.getInstance().atualizarMarco(landmark);
                    data.createProximityListener(coord);
                }
                catch (IOException e){
                    Alert alert = new Alert("Error", "Erro de Entrada/Saída", null, AlertType.ERROR);
                    display().setCurrent(alert);
                }
                catch (LandmarkException e){                   
                    Alert alert = new Alert("Error","Marco não localizado no Landmark Store.", null, AlertType.ERROR);
                    display().setCurrent(alert);
                }
                // atualiza o marco avaliado na lista
                showList();
            }
        }
        // retorna a tela anterior
        else if (command == cmdRoute){
           display().setCurrent(route);
        }
        // Show landmark editor for the selected landmark.
        else if (command == cmdUpdate){
            int index = list.getSelectedIndex();
            landmark = ControleMarcos.getInstance().proxMarco(index);
            showEditor(landmark.getQualifiedCoordinates(), MODE_UPDATE);
        }
        // Remove o marco selecionado do LandmarkStore
        else if (command == cmdRremove){
            try{
                int index = list.getSelectedIndex();
                landmark = ControleMarcos.getInstance().proxMarco(index);
                ControleMarcos.getInstance().removeMarco(landmark);

                Alert alert = new Alert("Information", "Marco removido com sucesso.", null, AlertType.INFO);
                display().setCurrent(alert);
            }
            catch (IOException e){
                Alert alert = new Alert("Error", "Erro de Entrada/Saída",null, AlertType.ERROR);
                display().setCurrent(alert);
            }
            catch (LandmarkException e){
                Alert alert = new Alert("Error", "Marco não localizado no Landmark Store.",
                        null, AlertType.ERROR);
                alert.setTimeout(3000); // 3 secs
                TouristMIDlet.getDisplay().setCurrent(alert);
            }
            showList();
        }
        // exibe a lista de marcos localizados
        else if (command == cmdList){
            showList();
        }
    }

    public static String formatDouble(double value, int decimals){
        String doubleStr = "" + value;
        int index = doubleStr.indexOf(".") != -1 ? doubleStr.indexOf("."): doubleStr.indexOf(",");
        // determina o ponto de decimal
        if (index == -1) return doubleStr;
        // trunca todos os decimais
        if (decimals == 0){
            return doubleStr.substring(0, index);
        }

        int len = index + decimals + 1;
        if (len >= doubleStr.length()) len = doubleStr.length();
        double d = Double.parseDouble(doubleStr.substring(0, len));
        return String.valueOf(d);
    }
}