am cf99765b: resolved conflicts for merge of 914ed90f to honeycomb-LTE (5389c80d) · Commits · e / os / android_frameworks_base

core/java/android/net/DhcpStateMachine.java

0 → 100644

+353 −0

Original line number	Diff line number	Diff line
		/*
		* 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 android.net;

		import com.android.internal.util.Protocol;
		import com.android.internal.util.State;
		import com.android.internal.util.StateMachine;

		import android.app.AlarmManager;
		import android.app.PendingIntent;
		import android.content.BroadcastReceiver;
		import android.content.Context;
		import android.content.Intent;
		import android.content.IntentFilter;
		import android.net.DhcpInfoInternal;
		import android.net.NetworkUtils;
		import android.os.Message;
		import android.os.PowerManager;
		import android.os.SystemClock;
		import android.util.Log;

		/**
		* StateMachine that interacts with the native DHCP client and can talk to
		* a controller that also needs to be a StateMachine
		*
		* The Dhcp state machine provides the following features:
		* - Wakeup and renewal using the native DHCP client (which will not renew
		* on its own when the device is in suspend state and this can lead to device
		* holding IP address beyond expiry)
		* - A notification right before DHCP request or renewal is started. This
		* can be used for any additional setup before DHCP. For example, wifi sets
		* BT-Wifi coex settings right before DHCP is initiated
		*
		* @hide
		*/
		public class DhcpStateMachine extends StateMachine {

		private static final String TAG = "DhcpStateMachine";
		private static final boolean DBG = false;


		/* A StateMachine that controls the DhcpStateMachine */
		private StateMachine mController;

		private Context mContext;
		private BroadcastReceiver mBroadcastReceiver;
		private AlarmManager mAlarmManager;
		private PendingIntent mDhcpRenewalIntent;
		private PowerManager.WakeLock mDhcpRenewWakeLock;
		private static final String WAKELOCK_TAG = "DHCP";

		private static final int DHCP_RENEW = 0;
		private static final String ACTION_DHCP_RENEW = "android.net.wifi.DHCP_RENEW";

		private enum DhcpAction {
		START,
		RENEW
		};

		private String mInterfaceName;
		private boolean mRegisteredForPreDhcpNotification = false;

		private static final int BASE = Protocol.BASE_DHCP;

		/* Commands from controller to start/stop DHCP */
		public static final int CMD_START_DHCP = BASE + 1;
		public static final int CMD_STOP_DHCP = BASE + 2;
		public static final int CMD_RENEW_DHCP = BASE + 3;

		/* Notification from DHCP state machine prior to DHCP discovery/renewal */
		public static final int CMD_PRE_DHCP_ACTION = BASE + 4;
		/* Notification from DHCP state machine post DHCP discovery/renewal. Indicates
		* success/failure */
		public static final int CMD_POST_DHCP_ACTION = BASE + 5;

		/* Command from controller to indicate DHCP discovery/renewal can continue
		* after pre DHCP action is complete */
		public static final int CMD_PRE_DHCP_ACTION_COMPLETE = BASE + 6;

		/* Message.arg1 arguments to CMD_POST_DHCP notification */
		public static final int DHCP_SUCCESS = 1;
		public static final int DHCP_FAILURE = 2;

		private State mDefaultState = new DefaultState();
		private State mStoppedState = new StoppedState();
		private State mWaitBeforeStartState = new WaitBeforeStartState();
		private State mRunningState = new RunningState();
		private State mWaitBeforeRenewalState = new WaitBeforeRenewalState();

		private DhcpStateMachine(Context context, StateMachine controller, String intf) {
		super(TAG);

		mContext = context;
		mController = controller;
		mInterfaceName = intf;

		mAlarmManager = (AlarmManager)mContext.getSystemService(Context.ALARM_SERVICE);
		Intent dhcpRenewalIntent = new Intent(ACTION_DHCP_RENEW, null);
		mDhcpRenewalIntent = PendingIntent.getBroadcast(mContext, DHCP_RENEW, dhcpRenewalIntent, 0);

		PowerManager powerManager = (PowerManager)mContext.getSystemService(Context.POWER_SERVICE);
		mDhcpRenewWakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, WAKELOCK_TAG);

		mBroadcastReceiver = new BroadcastReceiver() {
		@Override
		public void onReceive(Context context, Intent intent) {
		//DHCP renew
		if (DBG) Log.d(TAG, "Sending a DHCP renewal " + this);
		//acquire a 40s wakelock to finish DHCP renewal
		mDhcpRenewWakeLock.acquire(40000);
		sendMessage(CMD_RENEW_DHCP);
		}
		};
		mContext.registerReceiver(mBroadcastReceiver, new IntentFilter(ACTION_DHCP_RENEW));

		addState(mDefaultState);
		addState(mStoppedState, mDefaultState);
		addState(mWaitBeforeStartState, mDefaultState);
		addState(mRunningState, mDefaultState);
		addState(mWaitBeforeRenewalState, mDefaultState);

		setInitialState(mStoppedState);
		}

		public static DhcpStateMachine makeDhcpStateMachine(Context context, StateMachine controller,
		String intf) {
		DhcpStateMachine dsm = new DhcpStateMachine(context, controller, intf);
		dsm.start();
		return dsm;
		}

		/**
		* This sends a notification right before DHCP request/renewal so that the
		* controller can do certain actions before DHCP packets are sent out.
		* When the controller is ready, it sends a CMD_PRE_DHCP_ACTION_COMPLETE message
		* to indicate DHCP can continue
		*
		* This is used by Wifi at this time for the purpose of doing BT-Wifi coex
		* handling during Dhcp
		*/
		public void registerForPreDhcpNotification() {
		mRegisteredForPreDhcpNotification = true;
		}

		class DefaultState extends State {
		@Override
		public boolean processMessage(Message message) {
		if (DBG) Log.d(TAG, getName() + message.toString() + "\n");
		switch (message.what) {
		case CMD_RENEW_DHCP:
		Log.e(TAG, "Error! Failed to handle a DHCP renewal on " + mInterfaceName);
		break;
		case SM_QUIT_CMD:
		mContext.unregisterReceiver(mBroadcastReceiver);
		//let parent kill the state machine
		return NOT_HANDLED;
		default:
		Log.e(TAG, "Error! unhandled message " + message);
		break;
		}
		return HANDLED;
		}
		}


		class StoppedState extends State {
		@Override
		public void enter() {
		if (DBG) Log.d(TAG, getName() + "\n");
		}

		@Override
		public boolean processMessage(Message message) {
		boolean retValue = HANDLED;
		if (DBG) Log.d(TAG, getName() + message.toString() + "\n");
		switch (message.what) {
		case CMD_START_DHCP:
		if (mRegisteredForPreDhcpNotification) {
		/* Notify controller before starting DHCP */
		mController.sendMessage(CMD_PRE_DHCP_ACTION);
		transitionTo(mWaitBeforeStartState);
		} else {
		if (runDhcp(DhcpAction.START)) {
		transitionTo(mRunningState);
		}
		}
		break;
		case CMD_STOP_DHCP:
		//ignore
		break;
		default:
		retValue = NOT_HANDLED;
		break;
		}
		return retValue;
		}
		}

		class WaitBeforeStartState extends State {
		@Override
		public void enter() {
		if (DBG) Log.d(TAG, getName() + "\n");
		}

		@Override
		public boolean processMessage(Message message) {
		boolean retValue = HANDLED;
		if (DBG) Log.d(TAG, getName() + message.toString() + "\n");
		switch (message.what) {
		case CMD_PRE_DHCP_ACTION_COMPLETE:
		if (runDhcp(DhcpAction.START)) {
		transitionTo(mRunningState);
		} else {
		transitionTo(mStoppedState);
		}
		break;
		case CMD_STOP_DHCP:
		transitionTo(mStoppedState);
		break;
		case CMD_START_DHCP:
		//ignore
		break;
		default:
		retValue = NOT_HANDLED;
		break;
		}
		return retValue;
		}
		}

		class RunningState extends State {
		@Override
		public void enter() {
		if (DBG) Log.d(TAG, getName() + "\n");
		}

		@Override
		public boolean processMessage(Message message) {
		boolean retValue = HANDLED;
		if (DBG) Log.d(TAG, getName() + message.toString() + "\n");
		switch (message.what) {
		case CMD_STOP_DHCP:
		mAlarmManager.cancel(mDhcpRenewalIntent);
		if (!NetworkUtils.stopDhcp(mInterfaceName)) {
		Log.e(TAG, "Failed to stop Dhcp on " + mInterfaceName);
		}
		transitionTo(mStoppedState);
		break;
		case CMD_RENEW_DHCP:
		if (mRegisteredForPreDhcpNotification) {
		/* Notify controller before starting DHCP */
		mController.sendMessage(CMD_PRE_DHCP_ACTION);
		transitionTo(mWaitBeforeRenewalState);
		} else {
		if (!runDhcp(DhcpAction.RENEW)) {
		transitionTo(mStoppedState);
		}
		}
		break;
		case CMD_START_DHCP:
		//ignore
		break;
		default:
		retValue = NOT_HANDLED;
		}
		return retValue;
		}
		}

		class WaitBeforeRenewalState extends State {
		@Override
		public void enter() {
		if (DBG) Log.d(TAG, getName() + "\n");
		}

		@Override
		public boolean processMessage(Message message) {
		boolean retValue = HANDLED;
		if (DBG) Log.d(TAG, getName() + message.toString() + "\n");
		switch (message.what) {
		case CMD_STOP_DHCP:
		mAlarmManager.cancel(mDhcpRenewalIntent);
		if (!NetworkUtils.stopDhcp(mInterfaceName)) {
		Log.e(TAG, "Failed to stop Dhcp on " + mInterfaceName);
		}
		transitionTo(mStoppedState);
		break;
		case CMD_PRE_DHCP_ACTION_COMPLETE:
		if (runDhcp(DhcpAction.RENEW)) {
		transitionTo(mRunningState);
		} else {
		transitionTo(mStoppedState);
		}
		break;
		case CMD_START_DHCP:
		//ignore
		break;
		default:
		retValue = NOT_HANDLED;
		break;
		}
		return retValue;
		}
		}

		private boolean runDhcp(DhcpAction dhcpAction) {
		boolean success = false;
		DhcpInfoInternal dhcpInfoInternal = new DhcpInfoInternal();

		if (dhcpAction == DhcpAction.START) {
		Log.d(TAG, "DHCP request on " + mInterfaceName);
		success = NetworkUtils.runDhcp(mInterfaceName, dhcpInfoInternal);
		} else if (dhcpAction == DhcpAction.RENEW) {
		Log.d(TAG, "DHCP renewal on " + mInterfaceName);
		success = NetworkUtils.runDhcpRenew(mInterfaceName, dhcpInfoInternal);
		}

		if (success) {
		Log.d(TAG, "DHCP succeeded on " + mInterfaceName);
		//Do it a bit earlier than half the lease duration time
		//to beat the native DHCP client and avoid extra packets
		//48% for one hour lease time = 29 minutes
		mAlarmManager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP,
		SystemClock.elapsedRealtime() +
		dhcpInfoInternal.leaseDuration * 480, //in milliseconds
		mDhcpRenewalIntent);

		mController.obtainMessage(CMD_POST_DHCP_ACTION, DHCP_SUCCESS, 0, dhcpInfoInternal)
		.sendToTarget();
		} else {
		Log.d(TAG, "DHCP failed on " + mInterfaceName + ": " +
		NetworkUtils.getDhcpError());
		NetworkUtils.stopDhcp(mInterfaceName);
		mController.obtainMessage(CMD_POST_DHCP_ACTION, DHCP_FAILURE, 0)
		.sendToTarget();
		}
		return success;
		}
		}

core/java/android/net/NetworkUtils.java

+10 −0

Original line number	Diff line number	Diff line
		@@ -53,6 +53,16 @@ public class NetworkUtils {
		*/
		public native static boolean runDhcp(String interfaceName, DhcpInfoInternal ipInfo);

		/**
		* Initiate renewal on the Dhcp client daemon. This call blocks until it obtains
		* a result (either success or failure) from the daemon.
		* @param interfaceName the name of the interface to configure
		* @param ipInfo if the request succeeds, this object is filled in with
		* the IP address information.
		* @return {@code true} for success, {@code false} for failure
		*/
		public native static boolean runDhcpRenew(String interfaceName, DhcpInfoInternal ipInfo);

		/**
		* Shut down the DHCP client daemon.
		* @param interfaceName the name of the interface for which the daemon

core/jni/android_net_NetUtils.cpp

+32 −3

Original line number	Diff line number	Diff line
		@@ -36,6 +36,16 @@ int dhcp_do_request(const char *ifname,
		const char *dns2,
		const char *server,
		uint32_t *lease);

		int dhcp_do_request_renew(const char *ifname,
		const char *ipaddr,
		const char *gateway,
		uint32_t *prefixLength,
		const char *dns1,
		const char *dns2,
		const char *server,
		uint32_t *lease);

		int dhcp_stop(const char *ifname);
		int dhcp_release_lease(const char *ifname);
		char *dhcp_get_errmsg();
		@@ -91,7 +101,8 @@ static jint android_net_utils_resetConnections(JNIEnv* env, jobject clazz, jstri
		return (jint)result;
		}

		static jboolean android_net_utils_runDhcp(JNIEnv* env, jobject clazz, jstring ifname, jobject info)
		static jboolean android_net_utils_runDhcpCommon(JNIEnv* env, jobject clazz, jstring ifname,
		jobject info, bool renew)
		{
		int result;
		char ipaddr[PROPERTY_VALUE_MAX];
		@@ -105,8 +116,14 @@ static jboolean android_net_utils_runDhcp(JNIEnv* env, jobject clazz, jstring if
		const char *nameStr = env->GetStringUTFChars(ifname, NULL);
		if (nameStr == NULL) return (jboolean)false;

		if (renew) {
		result = ::dhcp_do_request_renew(nameStr, ipaddr, gateway, &prefixLength,
		dns1, dns2, server, &lease);
		} else {
		result = ::dhcp_do_request(nameStr, ipaddr, gateway, &prefixLength,
		dns1, dns2, server, &lease);
		}

		env->ReleaseStringUTFChars(ifname, nameStr);
		if (result == 0 && dhcpInfoInternalFieldIds.dhcpInfoInternalClass != NULL) {
		env->SetObjectField(info, dhcpInfoInternalFieldIds.ipaddress, env->NewStringUTF(ipaddr));
		@@ -144,6 +161,17 @@ static jboolean android_net_utils_runDhcp(JNIEnv* env, jobject clazz, jstring if
		return (jboolean)(result == 0);
		}

		static jboolean android_net_utils_runDhcp(JNIEnv* env, jobject clazz, jstring ifname, jobject info)
		{
		return android_net_utils_runDhcpCommon(env, clazz, ifname, info, false);
		}

		static jboolean android_net_utils_runDhcpRenew(JNIEnv* env, jobject clazz, jstring ifname, jobject info)
		{
		return android_net_utils_runDhcpCommon(env, clazz, ifname, info, true);
		}


		static jboolean android_net_utils_stopDhcp(JNIEnv* env, jobject clazz, jstring ifname)
		{
		int result;
		@@ -181,6 +209,7 @@ static JNINativeMethod gNetworkUtilMethods[] = {
		{ "disableInterface", "(Ljava/lang/String;)I", (void *)android_net_utils_disableInterface },
		{ "resetConnections", "(Ljava/lang/String;)I", (void *)android_net_utils_resetConnections },
		{ "runDhcp", "(Ljava/lang/String;Landroid/net/DhcpInfoInternal;)Z", (void *)android_net_utils_runDhcp },
		{ "runDhcpRenew", "(Ljava/lang/String;Landroid/net/DhcpInfoInternal;)Z", (void *)android_net_utils_runDhcpRenew },
		{ "stopDhcp", "(Ljava/lang/String;)Z", (void *)android_net_utils_stopDhcp },
		{ "releaseDhcpLease", "(Ljava/lang/String;)Z", (void *)android_net_utils_releaseDhcpLease },
		{ "getDhcpError", "()Ljava/lang/String;", (void*) android_net_utils_getDhcpError },

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

+151 −129

File changed.

Preview size limit exceeded, changes collapsed.