Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Support for dumping transition only messages"

Browse Source
This commit is contained in:
Irfan Sheriff
2012-11-30 09:41:51 -08:00
committed by Android (Google) Code Review
parent b686eceac9 ef8da9fe0b
commit 38ddedc8ad
2 changed files with 77 additions and 66 deletions
Download Patch File Download Diff File Expand all files Collapse all files

112
core/java/com/android/internal/util/StateMachine.java
View File

@@ -452,17 +452,20 @@ public class StateMachine {
private String mInfo;
private State mState;
private State mOrgState;
private State mTransitionToState;
/**
* Constructor
*
* @param msg
* @param state that handled the message
* @param state the state which handled the message
* @param orgState is the first state the received the message but
* did not processes the message.
* @param transToState is the state that was transitioned to after the message was
* processed.
*/
LogRec(Message msg, String info, State state, State orgState) {
update(msg, info, state, orgState);
LogRec(Message msg, String info, State state, State orgState, State transToState) {
update(msg, info, state, orgState, transToState);
}
/**
@@ -470,13 +473,17 @@ public class StateMachine {
* @param state that handled the message
* @param orgState is the first state the received the message but
* did not processes the message.
* @param transToState is the state that was transitioned to after the message was
* processed.
*/
public void update(Message msg, String info, State state, State orgState) {
public void update(Message msg, String info, State state, State orgState,
State transToState) {
mTime = System.currentTimeMillis();
mWhat = (msg != null) ? msg.what : 0;
mInfo = info;
mState = state;
mOrgState = orgState;
mTransitionToState = transToState;
}
/**
@@ -523,10 +530,12 @@ public class StateMachine {
Calendar c = Calendar.getInstance();
c.setTimeInMillis(mTime);
sb.append(String.format("%tm-%td %tH:%tM:%tS.%tL", c, c, c, c, c, c));
sb.append(" state=");
sb.append(" processed=");
sb.append(mState == null ? "<null>" : mState.getName());
sb.append(" orgState=");
sb.append(" org=");
sb.append(mOrgState == null ? "<null>" : mOrgState.getName());
sb.append(" dest=");
sb.append(mTransitionToState == null ? "<null>" : mTransitionToState.getName());
sb.append(" what=");
String what = sm.getWhatToString(mWhat);
if (TextUtils.isEmpty(what)) {
@@ -560,10 +569,11 @@ public class StateMachine {
private static final int DEFAULT_SIZE = 20;
private Vector<LogRec> mLogRecords = new Vector<LogRec>();
private Vector<LogRec> mLogRecVector = new Vector<LogRec>();
private int mMaxSize = DEFAULT_SIZE;
private int mOldestIndex = 0;
private int mCount = 0;
private boolean mLogOnlyTransitions = false;
/**
* private constructor use add
@@ -579,14 +589,22 @@ public class StateMachine {
synchronized void setSize(int maxSize) {
mMaxSize = maxSize;
mCount = 0;
mLogRecords.clear();
mLogRecVector.clear();
}
synchronized void setLogOnlyTransitions(boolean enable) {
mLogOnlyTransitions = enable;
}
synchronized boolean logOnlyTransitions() {
return mLogOnlyTransitions;
}
/**
* @return the number of recent records.
*/
synchronized int size() {
return mLogRecords.size();
return mLogRecVector.size();
}
/**
@@ -600,7 +618,7 @@ public class StateMachine {
* Clear the list of records.
*/
synchronized void cleanup() {
mLogRecords.clear();
mLogRecVector.clear();
}
/**
@@ -616,7 +634,7 @@ public class StateMachine {
if (nextIndex >= size()) {
return null;
} else {
return mLogRecords.get(nextIndex);
return mLogRecVector.get(nextIndex);
}
}
@@ -628,18 +646,22 @@ public class StateMachine {
* @param state that handled the message
* @param orgState is the first state the received the message but
* did not processes the message.
* @param transToState is the state that was transitioned to after the message was
* processed.
*
*/
synchronized void add(Message msg, String messageInfo, State state, State orgState) {
synchronized void add(Message msg, String messageInfo, State state, State orgState,
State transToState) {
mCount += 1;
if (mLogRecords.size() < mMaxSize) {
mLogRecords.add(new LogRec(msg, messageInfo, state, orgState));
if (mLogRecVector.size() < mMaxSize) {
mLogRecVector.add(new LogRec(msg, messageInfo, state, orgState, transToState));
} else {
LogRec pmi = mLogRecords.get(mOldestIndex);
LogRec pmi = mLogRecVector.get(mOldestIndex);
mOldestIndex += 1;
if (mOldestIndex >= mMaxSize) {
mOldestIndex = 0;
}
pmi.update(msg, messageInfo, state, orgState);
pmi.update(msg, messageInfo, state, orgState, transToState);
}
}
}
@@ -755,9 +777,11 @@ public class StateMachine {
/** Save the current message */
mMsg = msg;
/** State that processed the message */
State msgProcessedState = null;
if (mIsConstructionCompleted) {
/** Normal path */
processMsg(msg);
msgProcessedState = processMsg(msg);
} else if (!mIsConstructionCompleted &&
(mMsg.what == SM_INIT_CMD) && (mMsg.obj == mSmHandlerObj)) {
/** Initial one time path. */
@@ -767,21 +791,27 @@ public class StateMachine {
throw new RuntimeException("StateMachine.handleMessage: " +
"The start method not called, received msg: " + msg);
}
performTransitions();
performTransitions(msgProcessedState);
if (mDbg) Log.d(TAG, "handleMessage: X");
}
/**
* Do any transitions
* @param msgProcessedState is the state that processed the message
*/
private void performTransitions() {
private void performTransitions(State msgProcessedState) {
/**
* 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;
State orgState = mStateStack[mStateStackTopIndex].state;
/** Record whether message needs to be logged before transitions */
boolean recordLogMsg = mSm.recordLogRec(mMsg);
while (mDestState != null) {
if (mDbg) Log.d(TAG, "handleMessage: new destination call exit");
@@ -832,6 +862,18 @@ public class StateMachine {
mSm.onHalting();
}
}
if (mLogRecords.logOnlyTransitions()) {
/** Record only if there is a transition */
if (destState != null) {
mLogRecords.add(mMsg, mSm.getLogRecString(mMsg), msgProcessedState,
orgState, destState);
}
} else if (recordLogMsg) {
/** Record message */
mLogRecords.add(mMsg, mSm.getLogRecString(mMsg), msgProcessedState,
orgState, destState);
}
}
/**
@@ -892,8 +934,9 @@ public class StateMachine {
* 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.
* @return the state that processed the message
*/
private final void processMsg(Message msg) {
private final State processMsg(Message msg) {
StateInfo curStateInfo = mStateStack[mStateStackTopIndex];
if (mDbg) {
Log.d(TAG, "processMsg: " + curStateInfo.state.getName());
@@ -918,20 +961,8 @@ public class StateMachine {
Log.d(TAG, "processMsg: " + curStateInfo.state.getName());
}
}
/**
* Record that we processed the message
*/
if (mSm.recordLogRec(msg)) {
if (curStateInfo != null) {
State orgState = mStateStack[mStateStackTopIndex].state;
mLogRecords.add(msg, mSm.getLogRecString(msg), curStateInfo.state,
orgState);
} else {
mLogRecords.add(msg, mSm.getLogRecString(msg), null, null);
}
}
}
}
return (curStateInfo != null) ? curStateInfo.state : null;
}
/**
@@ -1346,6 +1377,15 @@ public class StateMachine {
mSmHandler.mLogRecords.setSize(maxSize);
}
/**
* Set to log only messages that cause a state transition
*
* @param enable {@code true} to enable, {@code false} to disable
*/
public final void setLogOnlyTransitions(boolean enable) {
mSmHandler.mLogRecords.setLogOnlyTransitions(enable);
}
/**
* @return number of log records
*/
@@ -1373,7 +1413,7 @@ public class StateMachine {
* @param string
*/
protected void addLogRec(String string) {
mSmHandler.mLogRecords.add(null, string, null, null);
mSmHandler.mLogRecords.add(null, string, null, null, null);
}
/**
@@ -1383,7 +1423,7 @@ public class StateMachine {
* @param state current state
*/
protected void addLogRec(String string, State state) {
mSmHandler.mLogRecords.add(null, string, state, null);
mSmHandler.mLogRecords.add(null, string, state, null, null);
}
/**

31
wifi/java/android/net/wifi/WifiStateMachine.java
View File

@@ -721,6 +721,7 @@ public class WifiStateMachine extends StateMachine {
setInitialState(mInitialState);
setLogRecSize(100);
setLogOnlyTransitions(true);
if (DBG) setDbg(true);
//start the state machine
@@ -1185,36 +1186,6 @@ public class WifiStateMachine extends StateMachine {
return sb.toString();
}
@Override
protected boolean recordLogRec(Message msg) {
//Ignore screen on/off & common messages when driver has started
if (getCurrentState() == mConnectedState || getCurrentState() == mDisconnectedState) {
switch (msg.what) {
case CMD_LOAD_DRIVER:
case CMD_START_SUPPLICANT:
case CMD_START_DRIVER:
case CMD_SET_SCAN_MODE:
case CMD_SET_HIGH_PERF_MODE:
case CMD_SET_SUSPEND_OPT_ENABLED:
case CMD_ENABLE_BACKGROUND_SCAN:
case CMD_ENABLE_ALL_NETWORKS:
return false;
}
}
switch (msg.what) {
case CMD_START_SCAN:
case CMD_ENABLE_RSSI_POLL:
case CMD_RSSI_POLL:
case CMD_DELAYED_STOP_DRIVER:
case WifiMonitor.SCAN_RESULTS_EVENT:
case WifiManager.RSSI_PKTCNT_FETCH:
return false;
default:
return true;
}
}
/*********************************************************
* Internal private functions
********************************************************/