import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;

/**
 *  SimpleBGMidlet
 */
public class SimpleBGMidlet extends MIDlet implements CommandListener {

/* Contador que sólo es necesario para mostrar un proceso que
está trabajando mientras la aplicación está en pausa.
El contador se incrementa por uno cada segundo mientras ejecuta la aplicación*/

private int count = 1;

//  User Interface related
private Command exitCmd  = new Command( "Exit",Command.EXIT, 2 );
protected Display display;

private Form form;

//SimpleBGProc es una clase interna que se define más abajo
private SimpleBGProc bg = new SimpleBGProc();
//el hilo que va a ejecutar el proceso de SimpleBGProc
private Thread thread;

/** Constructor */
public SimpleBGMidlet() {
}

/**
 *  Estado inicial.
 *  @throw MIDletStateChangeException para indicar que ocurrió un error en el
 *  cambio de estado
 */
public void startApp() throws MIDletStateChangeException {
    System.out.println("Llamado startApp");
    try {
        if (display == null) {
           System.out.println("Configurando...");
           display = Display.getDisplay(this);
           display.setCurrent(form);
        }
    }
    catch(Exception e) {
        System.out.println("Excepción durante startApp()");
        e.printStackTrace();
        //  If some kind of transient error ocurrs, throw a
        //  MIDledStateChangeException.
        throw new MIDletStateChangeException("Error iniciando...");
    }
    System.out.println("Comenzando pausa en seguida...");

    // el comando que sigue le indica al sistema Java del equipo que
    // debe pausar esta aplicación cuando pueda. El método pauseApp()
    // será llamado a su momento por el sistema.
    pauseApp();
    notifyPaused();
}

/** Estado de pausa. Es aquí donde debemos iniciar el thread que queremos que ejecute sólo en el fondo . */
public void pauseApp() {
        System.out.println("pauseApp llamado");
    thread = new Thread(bg);
    thread.start();
        display = null;
}

/**
 *  Destroyed state. Soltar todos los recursos en us (connection, threads, etc).
 *  Última oportunidad de guardar datos.
 *  @param uc Si verdadero, el MIDlet debe soltar todos los recursos que esté usando.
 *  Si falso, el MIDlet puede lanzar @throw MIDletStateChangeException para indicar
 *      que no quiere ser destruido en este momento.
 */
public void destroyApp(boolean uc)  {
        System.out.println("destroyApp llamado");
        bg.stopAll();
    display = null;
}

/**
 *  Respuesta a comandos
 *  @param c el comando LCDUI para procesar.
 *  @param d el Displayable que originó el comando.
 */
public void commandAction(Command c, Displayable d) {
    if (c == exitCmd) {
      destroyApp(false);
      notifyDestroyed();
    }
} // commandAction()

/* Clase sencilla que instancia un thread que, cada segundo, incrementa un contador
* y envía texto a la consola.
*/

private class SimpleBGProc implements Runnable {

    private int counter = 0;

    private static final int SLEEP_INITIAL = 2000; //2000 milésimas de segundo
    private boolean running = false;

    /**
     * constructor
     */
    public SimpleBGProc() {
                 running = true;
        }

    public void stopAll(){
                running = false; //llamando bg.stopAll() podemos detener el hilo limpiamente
    }

        //la función principal de la clase. Esta se llama cuando se inicia el thread
        //al que esta clase está asociada.
    public void run() {
                        System.out.println("starting thread");
                        Thread thisThread = Thread.currentThread();

                //el boolean permite que el thread continúe ejecutando mientras no lo interrumpa
                //algo más. Aquí podríamos, por ejemplo, pedir que una aplicación obtenga coordenadas
                //de GPS cada cierto tiempo, o que envíe datos a un servidor cada cierto tiempo,
                //o que revise cada cierto tiempo para ver si existe nueva información. Con tal
                //que este método no requiera interacción con un usuario, puede ejecutar en
                //el fondo por sí solo.

        while(running) {
            // ... operación recurrente ..
                        counter++;
            System.out.println("Counter: "+ counter);
            try {
                Thread.currentThread().sleep( SLEEP_INITIAL );
            }
            catch ( InterruptedException e ){
                        }
        }
    }

}

} //  SimpleBGMidlet