/** Start the state machine. */ public void start() { // mSmHandler can be null if the state machine has quit. if (mSmHandler == null) return; /** Send the complete construction message */ mSmHandler.completeConstruction(); }
/** Enqueue a message to this state machine after a delay. */ public final void sendMessageDelayed(Message msg, long delayMillis) { // mSmHandler can be null if the state machine has quit. if (mSmHandler == null) return; mSmHandler.sendMessageDelayed(msg, delayMillis); }
/** Enqueue a message to this state machine after a delay. */ public final void sendMessageDelayed(int what, Object obj, long delayMillis) { // mSmHandler can be null if the state machine has quit. if (mSmHandler == null) return; mSmHandler.sendMessageDelayed(obtainMessage(what, obj), delayMillis); }
/** Enqueue a message to this state machine. */ public final void sendMessage(Message msg) { // mSmHandler can be null if the state machine has quit. if (mSmHandler == null) return; mSmHandler.sendMessage(msg); }
/** @return current message */ protected final Message getCurrentMessage() { return mSmHandler.getCurrentMessage(); }
/** * Set debug enable/disabled. * * @param dbg is true to enable debugging. */ public void setDbg(boolean dbg) { // mSmHandler can be null if the state machine has quit. if (mSmHandler == null) return; mSmHandler.setDbg(dbg); }
/** @return ture if msg is quit */ protected final boolean isQuit(Message msg) { return mSmHandler.isQuit(msg); }
/** * Removes a message from the message queue. Protected, may only be called by instances of * StateMachine. */ protected final void removeMessages(int what) { mSmHandler.removeMessages(what); }
/** * Defer this message until next state transition. Upon transitioning all deferred messages will * be placed on the queue and reprocessed in the original order. (i.e. The next state the oldest * messages will be processed first) * * @param msg is deferred until the next transition. */ protected final void deferMessage(Message msg) { mSmHandler.deferMessage(msg); }
/** * transition to halt state. Upon returning from processMessage we will exit all current states, * execute the halting() method and then all subsequent messages haltedProcessMesage will be * called. */ protected final void transitionToHaltingState() { mSmHandler.transitionTo(mSmHandler.mHaltingState); }
/** * transition to destination state. Upon returning from processMessage the current state's exit * will be executed and upon the next message arriving destState.enter will be invoked. * * <p>this function can also be called inside the enter function of the previous transition * target, but the behavior is undefined when it is called mid-way through a previous transition * (for example, calling this in the enter() routine of a intermediate node when the current * transition target is one of the nodes descendants). * * @param destState will be the state that receives the next message. */ protected final void transitionTo(IState destState) { mSmHandler.transitionTo(destState); }
/** * Set the initial state. This must be invoked before and messages are sent to the state machine. * * @param initialState is the state which will receive the first message. */ protected final void setInitialState(State initialState) { mSmHandler.setInitialState(initialState); }
/** * Add a new state to the state machine, parent will be null * * @param state to add */ protected final void addState(State state) { mSmHandler.addState(state, null); }
/** @return current state */ protected final IState getCurrentState() { return mSmHandler.getCurrentState(); }
/** * Enqueue a message to the front of the queue for this state machine. Protected, may only be * called by instances of StateMachine. */ protected final void sendMessageAtFrontOfQueue(int what) { mSmHandler.sendMessageAtFrontOfQueue(obtainMessage(what)); }
/** * Enqueue a message to the front of the queue for this state machine. Protected, may only be * called by instances of StateMachine. */ protected final void sendMessageAtFrontOfQueue(Message msg) { mSmHandler.sendMessageAtFrontOfQueue(msg); }
/** * Set size of messages to maintain and clears all current messages. * * @param maxSize number of messages to maintain at anyone time. */ public final void setProcessedMessagesSize(int maxSize) { mSmHandler.setProcessedMessagesSize(maxSize); }
/** * Conditionally quit the looper and stop execution. * * <p>This sends the SM_QUIT_MSG to the state machine and if not handled by any state's * processMessage then the state machine will be stopped and no further messages will be * processed. */ public final void quit() { // mSmHandler can be null if the state machine has quit. if (mSmHandler == null) return; mSmHandler.quit(); }
/** @return the total number of messages processed */ public final int getProcessedMessagesCount() { return mSmHandler.getProcessedMessagesCount(); }
/** @return if debugging is enabled */ public boolean isDbg() { // mSmHandler can be null if the state machine has quit. if (mSmHandler == null) return false; return mSmHandler.isDbg(); }
/** @return a processed message information */ public final ProcessedMessageInfo getProcessedMessageInfo(int index) { return mSmHandler.getProcessedMessageInfo(index); }
/** Enqueue a message to this state machine. */ public final void sendMessage(int what, Object obj) { // mSmHandler can be null if the state machine has quit. if (mSmHandler == null) return; mSmHandler.sendMessage(obtainMessage(what, obj)); }
/** * Add a new state to the state machine * * @param state the state to add * @param parent the parent of state */ protected final void addState(State state, State parent) { mSmHandler.addState(state, parent); }