FileDocCategorySizeDatePackage
NetworkState.javaAPI DocAndroid 5.1 API9706Thu Mar 12 22:22:12 GMT 2015com.android.bandwidthtest

NetworkState

public class NetworkState extends Object
Data structure to keep track of the network state transitions.

Fields Summary
private final String
LOG_TAG
private List
mStateDepository
private android.net.NetworkInfo.State
mTransitionTarget
private StateTransitionDirection
mTransitionDirection
private String
mReason
Constructors Summary
public NetworkState()

         // record mReason of state transition failure

      
        mStateDepository = new ArrayList<State>();
        mTransitionDirection = StateTransitionDirection.DO_NOTHING;
        mTransitionTarget = State.UNKNOWN;
public NetworkState(android.net.NetworkInfo.State currentState)

        mStateDepository = new ArrayList<State>();
        mStateDepository.add(currentState);
        mTransitionDirection = StateTransitionDirection.DO_NOTHING;
        mTransitionTarget = State.UNKNOWN;
Methods Summary
public java.lang.StringgetFailureReason()
Fetch the reason for network state transition failure

return
the {@link String} for the failure

        return mReason;
public java.util.ListgetTransitionStates()
Fetch the different network state transitions

return
{@link List} of {@link State}

        return mStateDepository;
public java.lang.StringprintStates()
Print the network state

return
{@link String} representation of the network state

        StringBuilder stateBuilder = new StringBuilder();
        for (int i = 0; i < mStateDepository.size(); i++) {
            stateBuilder.append(" ").append(mStateDepository.get(i).toString()).append("->");
        }
        return stateBuilder.toString();
public voidrecordState(android.net.NetworkInfo.State currentState)
Record the current state of the network

param
currentState the current {@link State}

        mStateDepository.add(currentState);
public voidresetNetworkState()
Reinitialize the network state

        mStateDepository.clear();
        mTransitionDirection = StateTransitionDirection.DO_NOTHING;
        mTransitionTarget = State.UNKNOWN;
public voidsetStateTransitionCriteria(android.net.NetworkInfo.State initState, com.android.bandwidthtest.NetworkState$StateTransitionDirection transitionDir, android.net.NetworkInfo.State targetState)
Set the transition criteria

param
initState initial {@link State}
param
transitionDir explicit {@link StateTransitionDirection}
param
targetState desired {@link State}

        if (!mStateDepository.isEmpty()) {
            mStateDepository.clear();
        }
        mStateDepository.add(initState);
        mTransitionDirection = transitionDir;
        mTransitionTarget = targetState;
        Log.v(LOG_TAG, "setStateTransitionCriteria: " + printStates());
public java.lang.StringtoString()
{@inheritDoc}

        StringBuilder builder = new StringBuilder();
        builder.append("mTransitionDirection: ").append(mTransitionDirection.toString()).
        append("; ").append("states:").
        append(printStates()).append("; ");
        return builder.toString();
private booleanvalidateNetworkConnection()
Verify the network state to connection

return
false if any of the state transitions were not valid

        StringBuffer str = new StringBuffer("States ");
        str.append(printStates());
        if (mStateDepository.get(0) != State.DISCONNECTED) {
            str.append(String.format(" Initial state should be DISCONNECTED, but it is %s.",
                    mStateDepository.get(0)));
            mReason = str.toString();
            return false;
        }
        State lastState = mStateDepository.get(mStateDepository.size() - 1);
        if ( lastState != mTransitionTarget) {
            str.append(String.format(" Last state should be %s, but it is %s", mTransitionTarget,
                    lastState));
            mReason = str.toString();
            return false;
        }
        for (int i = 1; i < mStateDepository.size(); i++) {
            State preState = mStateDepository.get(i-1);
            State curState = mStateDepository.get(i);
            if ((preState == State.DISCONNECTED) && ((curState == State.CONNECTING) ||
                    (curState == State.CONNECTED) || (curState == State.DISCONNECTED))) {
                continue;
            } else if ((preState == State.CONNECTING) && (curState == State.CONNECTED)) {
                continue;
            } else if ((preState == State.CONNECTED) && (curState == State.CONNECTED)) {
                continue;
            } else {
                str.append(String.format(" Transition state from %s to %s is not valid.",
                        preState.toString(), curState.toString()));
                mReason = str.toString();
                return false;
            }
        }
        mReason = str.toString();
        return true;
private booleanvalidateNetworkDisconnection()
Verify the network state to disconnection

return
false if any of the state transitions were not valid

        // Transition from CONNECTED -> DISCONNECTED: CONNECTED->DISCONNECTING->DISCONNECTED
        StringBuffer str = new StringBuffer ("States: ");
        str.append(printStates());
        if (mStateDepository.get(0) != State.CONNECTED) {
            str.append(String.format(" Initial state should be CONNECTED, but it is %s.",
                    mStateDepository.get(0)));
            mReason = str.toString();
            return false;
        }
        State lastState = mStateDepository.get(mStateDepository.size() - 1);
        if ( lastState != mTransitionTarget) {
            str.append(String.format(" Last state should be DISCONNECTED, but it is %s",
                    lastState));
            mReason = str.toString();
            return false;
        }
        for (int i = 1; i < mStateDepository.size() - 1; i++) {
            State preState = mStateDepository.get(i-1);
            State curState = mStateDepository.get(i);
            if ((preState == State.CONNECTED) && ((curState == State.DISCONNECTING) ||
                    (curState == State.DISCONNECTED))) {
                continue;
            } else if ((preState == State.DISCONNECTING) && (curState == State.DISCONNECTED)) {
                continue;
            } else if ((preState == State.DISCONNECTED) && (curState == State.DISCONNECTED)) {
                continue;
            } else {
                str.append(String.format(" Transition state from %s to %s is not valid",
                        preState.toString(), curState.toString()));
                mReason = str.toString();
                return false;
            }
        }
        mReason = str.toString();
        return true;
private booleanvalidateNetworkStates()
Verify that network states are valid

return
false if any of the states are invalid

        if (mStateDepository.isEmpty()) {
            Log.v(LOG_TAG, "no state is recorded");
            mReason = "no state is recorded.";
            return false;
        } else if (mStateDepository.size() > 1) {
            Log.v(LOG_TAG, "no broadcast is expected, instead broadcast is probably received");
            mReason = "no broadcast is expected, instead broadcast is probably received";
            return false;
        } else if (mStateDepository.get(0) != mTransitionTarget) {
            Log.v(LOG_TAG, String.format("%s is expected, but it is %s",
                    mTransitionTarget.toString(),
                    mStateDepository.get(0).toString()));
            mReason = String.format("%s is expected, but it is %s",
                    mTransitionTarget.toString(),
                    mStateDepository.get(0).toString());
            return false;
        }
        return true;
public booleanvalidateStateTransition()
Verify the state transition

return
true if the requested transition completed successfully.

        Log.v(LOG_TAG, String.format("Print state depository: %s", printStates()));
        switch (mTransitionDirection) {
            case DO_NOTHING:
                Log.v(LOG_TAG, "No direction requested, verifying network states");
                return validateNetworkStates();
            case TO_CONNECTION:
                Log.v(LOG_TAG, "Transition to CONNECTED");
                return validateNetworkConnection();
            case TO_DISCONNECTION:
                Log.v(LOG_TAG, "Transition to DISCONNECTED");
                return validateNetworkDisconnection();
            default:
                Log.e(LOG_TAG, "Invalid transition direction.");
                return false;
        }