core/tests/bandwidthtests/src/com/android/bandwidthtest/NetworkState.java

/*
 * Copyright (C) 2011 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.bandwidthtest;

import android.net.NetworkInfo.State;
import android.util.Log;

import java.util.List;
import java.util.ArrayList;

/**
 * Data structure to keep track of the network state transitions.
 */
public class NetworkState {
    /**
     * Desired direction of state transition.
     */
    public enum StateTransitionDirection {
        TO_DISCONNECTION, TO_CONNECTION, DO_NOTHING
    }
    private final String LOG_TAG = "NetworkState";
    private List<State> mStateDepository;
    private State mTransitionTarget;
    private StateTransitionDirection mTransitionDirection;
    private String mReason = null;         // record mReason of state transition failure

    public NetworkState() {
        mStateDepository = new ArrayList<State>();
        mTransitionDirection = StateTransitionDirection.DO_NOTHING;
        mTransitionTarget = State.UNKNOWN;
    }

    public NetworkState(State currentState) {
        mStateDepository = new ArrayList<State>();
        mStateDepository.add(currentState);
        mTransitionDirection = StateTransitionDirection.DO_NOTHING;
        mTransitionTarget = State.UNKNOWN;
    }

    /**
     * Reinitialize the network state
     */
    public void resetNetworkState() {
        mStateDepository.clear();
        mTransitionDirection = StateTransitionDirection.DO_NOTHING;
        mTransitionTarget = State.UNKNOWN;
    }

    /**
     * Set the transition criteria
     * @param initState initial {@link State}
     * @param transitionDir explicit {@link StateTransitionDirection}
     * @param targetState desired {@link State}
     */
    public void setStateTransitionCriteria(State initState, StateTransitionDirection transitionDir,
            State targetState) {
        if (!mStateDepository.isEmpty()) {
            mStateDepository.clear();
        }
        mStateDepository.add(initState);
        mTransitionDirection = transitionDir;
        mTransitionTarget = targetState;
        Log.v(LOG_TAG, "setStateTransitionCriteria: " + printStates());
    }

    /**
     * Record the current state of the network
     * @param currentState  the current {@link State}
     */
    public void recordState(State currentState) {
        mStateDepository.add(currentState);
    }

    /**
     * Verify the state transition
     * @return true if the requested transition completed successfully.
     */
    public boolean validateStateTransition() {
        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;
        }
    }

    /**
     * Verify that network states are valid
     * @return false if any of the states are invalid
     */
    private boolean validateNetworkStates() {
        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;
    }

    /**
     * Verify the network state to disconnection
     * @return false if any of the state transitions were not valid
     */
    private boolean validateNetworkDisconnection() {
        // 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;
    }

    /**
     * Verify the network state to connection
     * @return false if any of the state transitions were not valid
     */
    private boolean validateNetworkConnection() {
        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;
    }

    /**
     * Fetch the different network state transitions
     * @return {@link List} of {@link State}
     */
    public List<State> getTransitionStates() {
        return mStateDepository;
    }

    /**
     * Fetch the reason for network state transition failure
     * @return the {@link String} for the failure
     */
    public String getFailureReason() {
        return mReason;
    }

    /**
     * Print the network state
     * @return {@link String} representation of the network state
     */
    public String printStates() {
        StringBuilder stateBuilder = new StringBuilder();
        for (int i = 0; i < mStateDepository.size(); i++) {
            stateBuilder.append(" ").append(mStateDepository.get(i).toString()).append("->");
        }
        return stateBuilder.toString();
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append("mTransitionDirection: ").append(mTransitionDirection.toString()).
        append("; ").append("states:").
        append(printStates()).append("; ");
        return builder.toString();
    }
}