Merge "Do a clean shutdown of p2p" into jb-mr1-dev (b98c2fb0) · Commits · e / os / android_frameworks_base

wifi/java/android/net/wifi/WifiStateMachine.java

+82 −5

Original line number	Diff line number	Diff line
		@@ -359,8 +359,12 @@ public class WifiStateMachine extends StateMachine {
		static final int CMD_RESET_SUPPLICANT_STATE = BASE + 111;

		/* P2p commands */
		/* We are ok with no response here since we wont do much with it anyway */
		public static final int CMD_ENABLE_P2P = BASE + 131;
		public static final int CMD_DISABLE_P2P = BASE + 132;
		/* In order to shut down supplicant cleanly, we wait till p2p has
		* been disabled */
		public static final int CMD_DISABLE_P2P_REQ = BASE + 132;
		public static final int CMD_DISABLE_P2P_RSP = BASE + 133;

		private static final int CONNECT_MODE = 1;
		private static final int SCAN_ONLY_MODE = 2;
		@@ -458,6 +462,11 @@ public class WifiStateMachine extends StateMachine {
		private State mDriverStartingState = new DriverStartingState();
		/* Driver started */
		private State mDriverStartedState = new DriverStartedState();
		/* Wait until p2p is disabled
		* This is a special state which is entered right after we exit out of DriverStartedState
		* before transitioning to another state.
		*/
		private State mWaitForP2pDisableState = new WaitForP2pDisableState();
		/* Driver stopping */
		private State mDriverStoppingState = new DriverStoppingState();
		/* Driver stopped */
		@@ -699,6 +708,7 @@ public class WifiStateMachine extends StateMachine {
		addState(mDisconnectingState, mConnectModeState);
		addState(mDisconnectedState, mConnectModeState);
		addState(mWpsRunningState, mConnectModeState);
		addState(mWaitForP2pDisableState, mSupplicantStartedState);
		addState(mDriverStoppingState, mSupplicantStartedState);
		addState(mDriverStoppedState, mSupplicantStartedState);
		addState(mSupplicantStoppingState, mDefaultState);
		@@ -2433,7 +2443,11 @@ public class WifiStateMachine extends StateMachine {
		WifiConfiguration config;
		switch(message.what) {
		case CMD_STOP_SUPPLICANT: /* Supplicant stopped by user */
		if (mP2pSupported) {
		transitionTo(mWaitForP2pDisableState);
		} else {
		transitionTo(mSupplicantStoppingState);
		}
		break;
		case WifiMonitor.SUP_DISCONNECTION_EVENT: /* Supplicant connection lost */
		loge("Connection lost, restart supplicant");
		@@ -2443,7 +2457,11 @@ public class WifiStateMachine extends StateMachine {
		handleNetworkDisconnect();
		sendSupplicantConnectionChangedBroadcast(false);
		mSupplicantStateTracker.sendMessage(CMD_RESET_SUPPLICANT_STATE);
		if (mP2pSupported) {
		transitionTo(mWaitForP2pDisableState);
		} else {
		transitionTo(mDriverLoadedState);
		}
		sendMessageDelayed(CMD_START_SUPPLICANT, SUPPLICANT_RESTART_INTERVAL_MSECS);
		break;
		case WifiMonitor.SCAN_RESULTS_EVENT:
		@@ -2838,8 +2856,12 @@ public class WifiStateMachine extends StateMachine {
		}
		mWakeLock.acquire();
		mWifiNative.stopDriver();
		transitionTo(mDriverStoppingState);
		mWakeLock.release();
		if (mP2pSupported) {
		transitionTo(mWaitForP2pDisableState);
		} else {
		transitionTo(mDriverStoppingState);
		}
		break;
		case CMD_START_PACKET_FILTERING:
		if (message.arg1 == MULTICAST_V6) {
		@@ -2885,8 +2907,63 @@ public class WifiStateMachine extends StateMachine {
		mIsRunning = false;
		updateBatteryWorkSource(null);
		mScanResults = new ArrayList<ScanResult>();
		}
		}

		if (mP2pSupported) mWifiP2pChannel.sendMessage(WifiStateMachine.CMD_DISABLE_P2P);
		class WaitForP2pDisableState extends State {
		private State mTransitionToState;
		@Override
		public void enter() {
		if (DBG) log(getName() + "\n");
		EventLog.writeEvent(EVENTLOG_WIFI_STATE_CHANGED, getName());
		switch (getCurrentMessage().what) {
		case WifiMonitor.SUP_DISCONNECTION_EVENT:
		mTransitionToState = mDriverLoadedState;
		break;
		case CMD_DELAYED_STOP_DRIVER:
		mTransitionToState = mDriverStoppingState;
		break;
		case CMD_STOP_SUPPLICANT:
		mTransitionToState = mSupplicantStoppingState;
		break;
		default:
		mTransitionToState = mDriverStoppingState;
		break;
		}
		mWifiP2pChannel.sendMessage(WifiStateMachine.CMD_DISABLE_P2P_REQ);
		}
		@Override
		public boolean processMessage(Message message) {
		if (DBG) log(getName() + message.toString() + "\n");
		switch(message.what) {
		case WifiStateMachine.CMD_DISABLE_P2P_RSP:
		transitionTo(mTransitionToState);
		break;
		/* Defer wifi start/shut and driver commands */
		case CMD_LOAD_DRIVER:
		case CMD_UNLOAD_DRIVER:
		case CMD_START_SUPPLICANT:
		case CMD_STOP_SUPPLICANT:
		case CMD_START_AP:
		case CMD_STOP_AP:
		case CMD_START_DRIVER:
		case CMD_STOP_DRIVER:
		case CMD_SET_SCAN_MODE:
		case CMD_SET_SCAN_TYPE:
		case CMD_SET_COUNTRY_CODE:
		case CMD_SET_FREQUENCY_BAND:
		case CMD_START_PACKET_FILTERING:
		case CMD_STOP_PACKET_FILTERING:
		case CMD_START_SCAN:
		case CMD_DISCONNECT:
		case CMD_REASSOCIATE:
		case CMD_RECONNECT:
		deferMessage(message);
		break;
		default:
		return NOT_HANDLED;
		}
		return HANDLED;
		}
		}

wifi/java/android/net/wifi/p2p/WifiP2pService.java

+35 −9

Original line number	Diff line number	Diff line
		@@ -134,6 +134,9 @@ public class WifiP2pService extends IWifiP2pManager.Stub {
		private static final int GROUP_CREATING_WAIT_TIME_MS = 120 * 1000;
		private static int mGroupCreatingTimeoutIndex = 0;

		private static final int DISABLE_P2P_WAIT_TIME_MS = 5 * 1000;
		private static int mDisableP2pTimeoutIndex = 0;

		/* Set a two minute discover timeout to avoid STA scans from being blocked */
		private static final int DISCOVER_TIMEOUT_S = 120;

		@@ -153,6 +156,8 @@ public class WifiP2pService extends IWifiP2pManager.Stub {
		private static final int DROP_WIFI_USER_ACCEPT = BASE + 4;
		/* User wants to keep his wifi connection and drop p2p */
		private static final int DROP_WIFI_USER_REJECT = BASE + 5;
		/* Delayed message to timeout p2p disable */
		public static final int DISABLE_P2P_TIMED_OUT = BASE + 6;


		/* Commands to the WifiStateMachine */
		@@ -574,19 +579,25 @@ public class WifiP2pService extends IWifiP2pManager.Stub {
		case WifiMonitor.P2P_DEVICE_LOST_EVENT:
		case WifiMonitor.P2P_FIND_STOPPED_EVENT:
		case WifiMonitor.P2P_SERV_DISC_RESP_EVENT:
		case WifiStateMachine.CMD_ENABLE_P2P:
		case WifiStateMachine.CMD_DISABLE_P2P:
		case PEER_CONNECTION_USER_ACCEPT:
		case PEER_CONNECTION_USER_REJECT:
		case DISCONNECT_WIFI_RESPONSE:
		case DROP_WIFI_USER_ACCEPT:
		case DROP_WIFI_USER_REJECT:
		case GROUP_CREATING_TIMED_OUT:
		case DISABLE_P2P_TIMED_OUT:
		case DhcpStateMachine.CMD_PRE_DHCP_ACTION:
		case DhcpStateMachine.CMD_POST_DHCP_ACTION:
		case DhcpStateMachine.CMD_ON_QUIT:
		case WifiMonitor.P2P_PROV_DISC_FAILURE_EVENT:
		break;
		case WifiStateMachine.CMD_ENABLE_P2P:
		// Enable is lazy and has no response
		break;
		case WifiStateMachine.CMD_DISABLE_P2P_REQ:
		// If we end up handling in default, p2p is not enabled
		mWifiChannel.sendMessage(WifiStateMachine.CMD_DISABLE_P2P_RSP);
		break;
		/* unexpected group created, remove */
		case WifiMonitor.P2P_GROUP_STARTED_EVENT:
		mGroup = (WifiP2pGroup) message.obj;
		@@ -688,6 +699,13 @@ public class WifiP2pService extends IWifiP2pManager.Stub {
		}

		class P2pDisablingState extends State {
		@Override
		public void enter() {
		if (DBG) logd(getName());
		sendMessageDelayed(obtainMessage(DISABLE_P2P_TIMED_OUT,
		++mDisableP2pTimeoutIndex, 0), DISABLE_P2P_WAIT_TIME_MS);
		}

		@Override
		public boolean processMessage(Message message) {
		if (DBG) logd(getName() + message.toString());
		@@ -697,14 +715,25 @@ public class WifiP2pService extends IWifiP2pManager.Stub {
		transitionTo(mP2pDisabledState);
		break;
		case WifiStateMachine.CMD_ENABLE_P2P:
		case WifiStateMachine.CMD_DISABLE_P2P:
		case WifiStateMachine.CMD_DISABLE_P2P_REQ:
		deferMessage(message);
		break;
		case DISABLE_P2P_TIMED_OUT:
		if (mGroupCreatingTimeoutIndex == message.arg1) {
		loge("P2p disable timed out");
		transitionTo(mP2pDisabledState);
		}
		break;
		default:
		return NOT_HANDLED;
		}
		return HANDLED;
		}

		@Override
		public void exit() {
		mWifiChannel.sendMessage(WifiStateMachine.CMD_DISABLE_P2P_RSP);
		}
		}

		class P2pDisabledState extends State {
		@@ -728,9 +757,6 @@ public class WifiP2pService extends IWifiP2pManager.Stub {
		mWifiMonitor.startMonitoring();
		transitionTo(mP2pEnablingState);
		break;
		case WifiStateMachine.CMD_DISABLE_P2P:
		//Nothing to do
		break;
		default:
		return NOT_HANDLED;
		}
		@@ -757,7 +783,7 @@ public class WifiP2pService extends IWifiP2pManager.Stub {
		transitionTo(mP2pDisabledState);
		break;
		case WifiStateMachine.CMD_ENABLE_P2P:
		case WifiStateMachine.CMD_DISABLE_P2P:
		case WifiStateMachine.CMD_DISABLE_P2P_REQ:
		deferMessage(message);
		break;
		default:
		@@ -788,7 +814,7 @@ public class WifiP2pService extends IWifiP2pManager.Stub {
		case WifiStateMachine.CMD_ENABLE_P2P:
		//Nothing to do
		break;
		case WifiStateMachine.CMD_DISABLE_P2P:
		case WifiStateMachine.CMD_DISABLE_P2P_REQ:
		if (mPeers.clear()) sendP2pPeersChangedBroadcast();
		if (mGroups.clear()) sendP2pPersistentGroupsChangedBroadcast();

		@@ -1534,7 +1560,7 @@ public class WifiP2pService extends IWifiP2pManager.Stub {
		}
		// Do the regular device lost handling
		return NOT_HANDLED;
		case WifiStateMachine.CMD_DISABLE_P2P:
		case WifiStateMachine.CMD_DISABLE_P2P_REQ:
		sendMessage(WifiP2pManager.REMOVE_GROUP);
		deferMessage(message);
		break;