/*
 * J2ME code example. Robot Timer Midlet.
 * Part of www.RoboHobby.com Java robotics project.
 * www.RoboHobby.com
 */

package com.robohobby.me;

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

/**

 *
 * RobotMIDlet
 *
 * @Ads.Taglet
 *

 * @author Oleg Lyubchenko
 */
public class RobotMIDlet extends MIDlet implements CommandListener {

    public boolean midletPaused = false;

    CallBacks callBacks = CallBacks.getInstance();

    //<editor-fold defaultstate="collapsed" desc=" Generated Fields ">                      

    private Command exitCommand;
    private Command startStopTimerCommand;
    private Command itemCommand;
    private Command infoItemCommand;
    private Form form;
    private StringItem timerInfoStringItem;
    private StringItem stateStringItem;
    //</editor-fold>                    

    /**
     * The RobotMIDlet constructor.
     */
    public RobotMIDlet() {
        callBacks.robotMIDlet = this;
    }

    //<editor-fold defaultstate="collapsed" desc=" Generated Methods ">                       

    //</editor-fold>                     

    //<editor-fold defaultstate="collapsed" desc=" Generated Method: initialize ">                                           
    /**
     * Initilizes the application.
     * It is called only once when the MIDlet is started.
     * The method is called before the <code>startMIDlet</code> method.
     */
    private void initialize() {
        // write pre-initialize user code here

        // write post-initialize user code here
    }
    //</editor-fold>                          

    //<editor-fold defaultstate="collapsed" desc=" Generated Method: startMIDlet ">                                        
    /**
     * Performs an action assigned to the Mobile Device - MIDlet Started point.

     */
    public void startMIDlet() {
        // write pre-action user code here
        switchDisplayable(null, getForm());
        // write post-action user code here

    }
    //</editor-fold>                           

    //<editor-fold defaultstate="collapsed" desc=" Generated Method: resumeMIDlet ">                                         

    /**
     * Performs an action assigned to the Mobile Device - MIDlet Resumed point.

     */
    public void resumeMIDlet() {
        // write pre-action user code here

        // write post-action user code here
    }
    //</editor-fold>                            

    //<editor-fold defaultstate="collapsed" desc=" Generated Method: switchDisplayable ">                                              
    /**
     * Switches a current displayable in a display.
     * The <code>display</code> instance is taken from <code>getDisplay</code> method.
     * This method is used by all actions in the design for switching displayable.
     * @param alert the Alert which is temporarily set to the display; 
     * if <code>null</code>, then <code>nextDisplayable</code> is set immediately
     * @param nextDisplayable the Displayable to be set
     */

    public void switchDisplayable(Alert alert, Displayable nextDisplayable) {
        // write pre-switch user code here
        Display display = getDisplay();
        if (alert == null) {
            display.setCurrent(nextDisplayable);
        } else {
            display.setCurrent(alert, nextDisplayable);
        }
        // write post-switch user code here

    }
    //</editor-fold>                                 

    //<editor-fold defaultstate="collapsed" desc=" Generated Method: commandAction for Displayables ">                                                 

    /**
     * Called by a system to indicated that a command has been invoked on a particular displayable.

     * @param command the Command that was invoked
     * @param displayable the Displayable where the command was invoked

     */
    public void commandAction(Command command, Displayable displayable) {
        // write pre-action user code here
        if (displayable == form) {
            if (command == exitCommand) {
                // write pre-action user code here

                exitMIDlet();
                // write post-action user code here
            } else if (command == startStopTimerCommand) {
                // write pre-action user code here

                // write post-action user code here
                doStartStopTimer();
            }
        }
        // write post-action user code here

    }
    //</editor-fold>                                          



    //<editor-fold defaultstate="collapsed" desc=" Generated Getter: exitCommand ">                                   

    /**
     * Returns an initiliazed instance of exitCommand component.

     * @return the initialized component instance
     */
    public Command getExitCommand() {
        if (exitCommand == null) {
            // write pre-init user code here

            exitCommand = new Command("Exit", Command.EXIT, 0);
            // write post-init user code here
        }
        return exitCommand;
    }
    //</editor-fold>                       

    //<editor-fold defaultstate="collapsed" desc=" Generated Getter: form ">                                   
    /**
     * Returns an initiliazed instance of form component.

     * @return the initialized component instance
     */
    public Form getForm() {
        if (form == null) {
            // write pre-init user code here

            form = new Form("www.RoboHobby.com", new Item[] { getTimerInfoStringItem(), getStateStringItem() });
            form.addCommand(getExitCommand());
            form.addCommand(getStartStopTimerCommand());
            form.setCommandListener(this);
            // write post-init user code here
        }
        return form;
    }
    //</editor-fold>                       

    //<editor-fold defaultstate="collapsed" desc=" Generated Getter: timerInfoStringItem ">                                   
    /**
     * Returns an initiliazed instance of timerInfoStringItem component.

     * @return the initialized component instance
     */
    public StringItem getTimerInfoStringItem() {
        if (timerInfoStringItem == null) {
            // write pre-init user code here

            timerInfoStringItem = new StringItem("Timer: ", "", Item.PLAIN);
            // write post-init user code here
        }
        return timerInfoStringItem;
    }
    //</editor-fold>                       

    //<editor-fold defaultstate="collapsed" desc=" Generated Getter: startStopTimerCommand ">                                   
    /**
     * Returns an initiliazed instance of startStopTimerCommand component.

     * @return the initialized component instance
     */
    public Command getStartStopTimerCommand() {
        if (startStopTimerCommand == null) {
            // write pre-init user code here

            startStopTimerCommand = new Command("Start/Stop Timer", Command.ITEM, 0);
            // write post-init user code here
        }
        return startStopTimerCommand;
    }
    //</editor-fold>                       

    //<editor-fold defaultstate="collapsed" desc=" Generated Getter: itemCommand ">                                   
    /**
     * Returns an initiliazed instance of itemCommand component.

     * @return the initialized component instance
     */
    public Command getItemCommand() {
        if (itemCommand == null) {
            // write pre-init user code here

            itemCommand = new Command("Item", Command.ITEM, 0);
            // write post-init user code here
        }
        return itemCommand;
    }
    //</editor-fold>                       

    //<editor-fold defaultstate="collapsed" desc=" Generated Getter: infoItemCommand ">                                   
    /**
     * Returns an initiliazed instance of infoItemCommand component.

     * @return the initialized component instance
     */
    public Command getInfoItemCommand() {
        if (infoItemCommand == null) {
            // write pre-init user code here

            infoItemCommand = new Command("State: ", Command.ITEM, 0);
            // write post-init user code here
        }
        return infoItemCommand;
    }
    //</editor-fold>                       

    //<editor-fold defaultstate="collapsed" desc=" Generated Getter: stateStringItem ">                                   
    /**
     * Returns an initiliazed instance of stateStringItem component.

     * @return the initialized component instance
     */
    public StringItem getStateStringItem() {
        if (stateStringItem == null) {
            // write pre-init user code here

            stateStringItem = new StringItem("State: ", "");
            // write post-init user code here
        }
        return stateStringItem;
    }
    //</editor-fold>                       

    /**
     * Returns a display instance.
     * @return the display instance.

     */
    public Display getDisplay () {
        return Display.getDisplay(this);
    }

    /**
     * Exits MIDlet.

     */
    public void exitMIDlet() {
        switchDisplayable (null, null);
        destroyApp(true);
        notifyDestroyed();
    }

    boolean timerIsRunning = false;
    java.util.Timer timer = null;
    int timerDelay = 300;
    int keyCounter = 0;

    RobotTimerTask robotTimerTask = null;

    public void doStartStopTimer()
    {
        System.out.println( "timerIsRunning="+timerIsRunning + " keyCounter="+keyCounter );
        keyCounter++;

        if ( timerIsRunning )
        {
            System.out.println( "Stopping Timer." );
            try

            {
                this.stateStringItem.setText( "Stopped" );
                robotTimerTask.doStop();
            }
            catch ( Exception e )
            {
                System.out.println( "Stopping Timer Error e=" + e );
            }
            timerIsRunning = false;
        }
        else

        {
            System.out.println( "Starting Timer:" );
            try
            {
                this.stateStringItem.setText( "Started" );
                robotTimerTask = new RobotTimerTask();
                timer = null;

                timer = new java.util.Timer();
                timer.schedule( robotTimerTask, 0L, timerDelay );
            }
            catch ( Exception e )
            {
                System.out.println( "Starting Timer Error e=" + e );
            }
            timerIsRunning = true;
        }
    }

    public void setTimerInfo( String timerInfo )
    {
        this.timerInfoStringItem.setText( timerInfo );
    }

    /**

     * Called when MIDlet is started.
     * Checks whether the MIDlet have been already started and initialize/starts or resumes the MIDlet.

     */
    public void startApp() {
        if (midletPaused) {
            resumeMIDlet ();
        } else {
            initialize ();
            startMIDlet ();
        }
        midletPaused = false;
    }

    /**

     * Called when MIDlet is paused.
     */
    public void pauseApp() {
        midletPaused = true;
    }

    /**
     * Called to signal the MIDlet to terminate.
     * @param unconditional if true, then the MIDlet has to be
     * unconditionally terminated and all resources has to be released.
     */
    public void destroyApp(boolean unconditional) {
    }

}