StateMachine与State模式的详细介绍可以参考文章：Android学习 StateMachine与State模式
下面是我对于StateMachine的理解：
先了解下消息处理。看下StateMachine::sendMessage方法。
不管BT/Wifi中，都有继承StateMachine的子类(BluetoothAdapterStateMachine.java/WifiStateMachine.java)，在某些类中，会创建这些类的对象，当需要发送消息时，会调用它们的sendMessage方法，即调用父类StateMachine的sendMessage方法。
/**
* Enqueue a message to this state machine.
*/
public final void sendMessage(int what) {
// mSmHandler can be null if the state machine has quit.
if (mSmHandler == null) return; mSmHandler.sendMessage(obtainMessage(what));
} /**
* 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));
} /**
* 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);
}
从sendMessage方法中可以看到，实际上是调用了StateMachine::SmHandler::sendMessage方法，该类没有实现该方法，所以会调用父类Handler::sendMessage方法，然后会调用StateMachine::SmHandler::handleMessage方法进行处理：
/**
* Handle messages sent to the state machine by calling
* the current state's processMessage. It also handles
* the enter/exit calls and placing any deferred messages
* back onto the queue when transitioning to a new state.
*/
@Override
public final void handleMessage(Message msg) {
if (mDbg) Log.d(TAG, "handleMessage: E msg.what=" + msg.what); /** Save the current message */
mMsg = msg; if (mIsConstructionCompleted) {
/** Normal path */
processMsg(msg); //1
} else if (!mIsConstructionCompleted &&
(mMsg.what == SM_INIT_CMD) && (mMsg.obj == mSmHandlerObj)) {
/** Initial one time path. */
mIsConstructionCompleted = true;
invokeEnterMethods(0);
} else {
throw new RuntimeException("StateMachine.handleMessage: " +
"The start method not called, received msg: " + msg);
}
performTransitions(); //2 if (mDbg) Log.d(TAG, "handleMessage: X");
}
该方法中有两个重要的方法：
1.processMsg(msg);
/**
* Process the message. If the current state doesn't handle
* it, call the states parent and so on. If it is never handled then
* call the state machines unhandledMessage method.
*/
private final void processMsg(Message msg) {
StateInfo curStateInfo = mStateStack[mStateStackTopIndex];
if (mDbg) {
Log.d(TAG, "processMsg: " + curStateInfo.state.getName());
}
while (!curStateInfo.state.processMessage(msg)) {
/**
* Not processed
*/
curStateInfo = curStateInfo.parentStateInfo;
if (curStateInfo == null) {
/**
* No parents left so it's not handled
*/
mSm.unhandledMessage(msg);
if (isQuit(msg)) {
transitionTo(mQuittingState);
}
break;
}
if (mDbg) {
Log.d(TAG, "processMsg: " + curStateInfo.state.getName());
}
} /**
* Record that we processed the message
*/
if (mSm.recordProcessedMessage(msg)) {
if (curStateInfo != null) {
State orgState = mStateStack[mStateStackTopIndex].state;
mProcessedMessages.add(msg, mSm.getMessageInfo(msg), curStateInfo.state,
orgState);
} else {
mProcessedMessages.add(msg, mSm.getMessageInfo(msg), null, null);
}
}
}
这个方法中有一个while循环，看下条件：curStateInfo.state.processMessage(msg)，即调用当前状态(State具体的子类)的processMessage方法。在具体实现的State子类中，在processMessage方法中，在具体的case处理完message后，会返回true 或 false(true的话会使得上述代码中的while循环退出，即该消息不上传给父状态处理，自己处理完就好了；false的话，就是再上传给父状态处理)。
2.performTransitions();
/**
* Do any transitions
*/
private void performTransitions() {
/**
* If transitionTo has been called, exit and then enter
* the appropriate states. We loop on this to allow
* enter and exit methods to use transitionTo.
*/
State destState = null;
while (mDestState != null) {
if (mDbg) Log.d(TAG, "handleMessage: new destination call exit"); /**
* Save mDestState locally and set to null
* to know if enter/exit use transitionTo.
*/
destState = mDestState;
mDestState = null; /**
* Determine the states to exit and enter and return the
* common ancestor state of the enter/exit states. Then
* invoke the exit methods then the enter methods.
*/
StateInfo commonStateInfo = setupTempStateStackWithStatesToEnter(destState);
invokeExitMethods(commonStateInfo);
int stateStackEnteringIndex = moveTempStateStackToStateStack();
invokeEnterMethods(stateStackEnteringIndex); /**
* Since we have transitioned to a new state we need to have
* any deferred messages moved to the front of the message queue
* so they will be processed before any other messages in the
* message queue.
*/
moveDeferredMessageAtFrontOfQueue();
} /**
* After processing all transitions check and
* see if the last transition was to quit or halt.
*/
if (destState != null) {
if (destState == mQuittingState) {
cleanupAfterQuitting(); } else if (destState == mHaltingState) {
/**
* Call halting() if we've transitioned to the halting
* state. All subsequent messages will be processed in
* in the halting state which invokes haltedProcessMessage(msg);
*/
mSm.halting();
}
}
}
这个方法主要是完成：
1.当前状态的切换，
2.更新状态栈。
比如状态已经通过addState方法添加完毕，形成了树形结构。当前状态是S4，现在要切换到S5。performTransitions方法中会完成一项功能：pop S4 S1，push S2 S5。