Merge "Refactor isTetheringSupported() calls" (6f63d051) · Commits · e / os / android_frameworks_base

services/core/java/com/android/server/ConnectivityService.java

+6 −1

Original line number	Original line	Diff line number	Diff line
	@@ -878,7 +878,12 @@ public class ConnectivityService extends IConnectivityManager.Stub

	private Tethering makeTethering() {		private Tethering makeTethering() {
	// TODO: Move other elements into @Overridden getters.		// TODO: Move other elements into @Overridden getters.
	final TetheringDependencies deps = new TetheringDependencies();		final TetheringDependencies deps = new TetheringDependencies() {
			@Override
			public boolean isTetheringSupported() {
			return ConnectivityService.this.isTetheringSupported();
			}
			};
	return new Tethering(mContext, mNetd, mStatsService, mPolicyManager,		return new Tethering(mContext, mNetd, mStatsService, mPolicyManager,
	IoThread.get().getLooper(), new MockableSystemProperties(),		IoThread.get().getLooper(), new MockableSystemProperties(),
	deps);		deps);

services/core/java/com/android/server/connectivity/Tethering.java

+88 −78

Original line number	Original line	Diff line number	Diff line
	@@ -19,6 +19,27 @@ package com.android.server.connectivity;
	import static android.hardware.usb.UsbManager.USB_CONFIGURED;		import static android.hardware.usb.UsbManager.USB_CONFIGURED;
	import static android.hardware.usb.UsbManager.USB_CONNECTED;		import static android.hardware.usb.UsbManager.USB_CONNECTED;
	import static android.hardware.usb.UsbManager.USB_FUNCTION_RNDIS;		import static android.hardware.usb.UsbManager.USB_FUNCTION_RNDIS;
			import static android.net.ConnectivityManager.ACTION_TETHER_STATE_CHANGED;
			import static android.net.ConnectivityManager.CONNECTIVITY_ACTION;
			import static android.net.ConnectivityManager.EXTRA_ACTIVE_LOCAL_ONLY;
			import static android.net.ConnectivityManager.EXTRA_ACTIVE_TETHER;
			import static android.net.ConnectivityManager.EXTRA_ADD_TETHER_TYPE;
			import static android.net.ConnectivityManager.EXTRA_AVAILABLE_TETHER;
			import static android.net.ConnectivityManager.EXTRA_ERRORED_TETHER;
			import static android.net.ConnectivityManager.EXTRA_NETWORK_INFO;
			import static android.net.ConnectivityManager.EXTRA_PROVISION_CALLBACK;
			import static android.net.ConnectivityManager.EXTRA_REM_TETHER_TYPE;
			import static android.net.ConnectivityManager.EXTRA_RUN_PROVISION;
			import static android.net.ConnectivityManager.EXTRA_SET_ALARM;
			import static android.net.ConnectivityManager.TETHER_ERROR_MASTER_ERROR;
			import static android.net.ConnectivityManager.TETHER_ERROR_NO_ERROR;
			import static android.net.ConnectivityManager.TETHER_ERROR_SERVICE_UNAVAIL;
			import static android.net.ConnectivityManager.TETHER_ERROR_UNKNOWN_IFACE;
			import static android.net.ConnectivityManager.TETHER_ERROR_UNAVAIL_IFACE;
			import static android.net.ConnectivityManager.TETHERING_BLUETOOTH;
			import static android.net.ConnectivityManager.TETHERING_INVALID;
			import static android.net.ConnectivityManager.TETHERING_USB;
			import static android.net.ConnectivityManager.TETHERING_WIFI;
	import static android.net.NetworkCapabilities.TRANSPORT_CELLULAR;		import static android.net.NetworkCapabilities.TRANSPORT_CELLULAR;
	import static android.net.wifi.WifiManager.EXTRA_WIFI_AP_INTERFACE_NAME;		import static android.net.wifi.WifiManager.EXTRA_WIFI_AP_INTERFACE_NAME;
	import static android.net.wifi.WifiManager.EXTRA_WIFI_AP_MODE;		import static android.net.wifi.WifiManager.EXTRA_WIFI_AP_MODE;
	@@ -45,7 +66,6 @@ import android.content.Intent;
	import android.content.IntentFilter;		import android.content.IntentFilter;
	import android.content.res.Resources;		import android.content.res.Resources;
	import android.hardware.usb.UsbManager;		import android.hardware.usb.UsbManager;
	import android.net.ConnectivityManager;
	import android.net.INetworkPolicyManager;		import android.net.INetworkPolicyManager;
	import android.net.INetworkStatsService;		import android.net.INetworkStatsService;
	import android.net.IpPrefix;		import android.net.IpPrefix;
	@@ -148,7 +168,7 @@ public class Tethering extends BaseNetworkObserver {
	stateMachine = sm;		stateMachine = sm;
	// Assume all state machines start out available and with no errors.		// Assume all state machines start out available and with no errors.
	lastState = IControlsTethering.STATE_AVAILABLE;		lastState = IControlsTethering.STATE_AVAILABLE;
	lastError = ConnectivityManager.TETHER_ERROR_NO_ERROR;		lastError = TETHER_ERROR_NO_ERROR;
	}		}

	public boolean isCurrentlyServing() {		public boolean isCurrentlyServing() {
	@@ -216,7 +236,7 @@ public class Tethering extends BaseNetworkObserver {

	final Handler smHandler = mTetherMasterSM.getHandler();		final Handler smHandler = mTetherMasterSM.getHandler();
	mOffloadController = new OffloadController(smHandler,		mOffloadController = new OffloadController(smHandler,
	deps.getOffloadHardwareInterface(smHandler, mLog),		mDeps.getOffloadHardwareInterface(smHandler, mLog),
	mContext.getContentResolver(), mNMService,		mContext.getContentResolver(), mNMService,
	mLog);		mLog);
	mUpstreamNetworkMonitor = deps.getUpstreamNetworkMonitor(mContext, mTetherMasterSM, mLog,		mUpstreamNetworkMonitor = deps.getUpstreamNetworkMonitor(mContext, mTetherMasterSM, mLog,
	@@ -243,7 +263,7 @@ public class Tethering extends BaseNetworkObserver {
	mStateReceiver = new StateReceiver();		mStateReceiver = new StateReceiver();
	filter = new IntentFilter();		filter = new IntentFilter();
	filter.addAction(UsbManager.ACTION_USB_STATE);		filter.addAction(UsbManager.ACTION_USB_STATE);
	filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);		filter.addAction(CONNECTIVITY_ACTION);
	filter.addAction(WifiManager.WIFI_AP_STATE_CHANGED_ACTION);		filter.addAction(WifiManager.WIFI_AP_STATE_CHANGED_ACTION);
	filter.addAction(Intent.ACTION_CONFIGURATION_CHANGED);		filter.addAction(Intent.ACTION_CONFIGURATION_CHANGED);
	mContext.registerReceiver(mStateReceiver, filter, null, smHandler);		mContext.registerReceiver(mStateReceiver, filter, null, smHandler);
	@@ -264,12 +284,6 @@ public class Tethering extends BaseNetworkObserver {
	updateConfiguration();		updateConfiguration();
	}		}

	// We can't do this once in the Tethering() constructor and cache the value, because the
	// CONNECTIVITY_SERVICE is registered only after the Tethering() constructor has completed.
	private ConnectivityManager getConnectivityManager() {
	return (ConnectivityManager) mContext.getSystemService(Context.CONNECTIVITY_SERVICE);
	}

	private WifiManager getWifiManager() {		private WifiManager getWifiManager() {
	return (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);		return (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);
	}		}
	@@ -295,7 +309,7 @@ public class Tethering extends BaseNetworkObserver {
	if (up) {		if (up) {
	maybeTrackNewInterfaceLocked(iface);		maybeTrackNewInterfaceLocked(iface);
	} else {		} else {
	if (ifaceNameToType(iface) == ConnectivityManager.TETHERING_BLUETOOTH) {		if (ifaceNameToType(iface) == TETHERING_BLUETOOTH) {
	stopTrackingInterfaceLocked(iface);		stopTrackingInterfaceLocked(iface);
	} else {		} else {
	// Ignore usb0 down after enabling RNDIS.		// Ignore usb0 down after enabling RNDIS.
	@@ -317,13 +331,13 @@ public class Tethering extends BaseNetworkObserver {
	final TetheringConfiguration cfg = mConfig;		final TetheringConfiguration cfg = mConfig;

	if (cfg.isWifi(iface)) {		if (cfg.isWifi(iface)) {
	return ConnectivityManager.TETHERING_WIFI;		return TETHERING_WIFI;
	} else if (cfg.isUsb(iface)) {		} else if (cfg.isUsb(iface)) {
	return ConnectivityManager.TETHERING_USB;		return TETHERING_USB;
	} else if (cfg.isBluetooth(iface)) {		} else if (cfg.isBluetooth(iface)) {
	return ConnectivityManager.TETHERING_BLUETOOTH;		return TETHERING_BLUETOOTH;
	}		}
	return ConnectivityManager.TETHERING_INVALID;		return TETHERING_INVALID;
	}		}

	@Override		@Override
	@@ -425,26 +439,26 @@ public class Tethering extends BaseNetworkObserver {
	boolean isProvisioningRequired = enable && isTetherProvisioningRequired();		boolean isProvisioningRequired = enable && isTetherProvisioningRequired();
	int result;		int result;
	switch (type) {		switch (type) {
	case ConnectivityManager.TETHERING_WIFI:		case TETHERING_WIFI:
	result = setWifiTethering(enable);		result = setWifiTethering(enable);
	if (isProvisioningRequired && result == ConnectivityManager.TETHER_ERROR_NO_ERROR) {		if (isProvisioningRequired && result == TETHER_ERROR_NO_ERROR) {
	scheduleProvisioningRechecks(type);		scheduleProvisioningRechecks(type);
	}		}
	sendTetherResult(receiver, result);		sendTetherResult(receiver, result);
	break;		break;
	case ConnectivityManager.TETHERING_USB:		case TETHERING_USB:
	result = setUsbTethering(enable);		result = setUsbTethering(enable);
	if (isProvisioningRequired && result == ConnectivityManager.TETHER_ERROR_NO_ERROR) {		if (isProvisioningRequired && result == TETHER_ERROR_NO_ERROR) {
	scheduleProvisioningRechecks(type);		scheduleProvisioningRechecks(type);
	}		}
	sendTetherResult(receiver, result);		sendTetherResult(receiver, result);
	break;		break;
	case ConnectivityManager.TETHERING_BLUETOOTH:		case TETHERING_BLUETOOTH:
	setBluetoothTethering(enable, receiver);		setBluetoothTethering(enable, receiver);
	break;		break;
	default:		default:
	Log.w(TAG, "Invalid tether type.");		Log.w(TAG, "Invalid tether type.");
	sendTetherResult(receiver, ConnectivityManager.TETHER_ERROR_UNKNOWN_IFACE);		sendTetherResult(receiver, TETHER_ERROR_UNKNOWN_IFACE);
	}		}
	}		}

	@@ -455,7 +469,7 @@ public class Tethering extends BaseNetworkObserver {
	}		}

	private int setWifiTethering(final boolean enable) {		private int setWifiTethering(final boolean enable) {
	int rval = ConnectivityManager.TETHER_ERROR_MASTER_ERROR;		int rval = TETHER_ERROR_MASTER_ERROR;
	final long ident = Binder.clearCallingIdentity();		final long ident = Binder.clearCallingIdentity();
	try {		try {
	synchronized (mPublicSync) {		synchronized (mPublicSync) {
	@@ -463,7 +477,7 @@ public class Tethering extends BaseNetworkObserver {
	final WifiManager mgr = getWifiManager();		final WifiManager mgr = getWifiManager();
	if ((enable && mgr.startSoftAp(null /* use existing wifi config */)) \|\|		if ((enable && mgr.startSoftAp(null /* use existing wifi config */)) \|\|
	(!enable && mgr.stopSoftAp())) {		(!enable && mgr.stopSoftAp())) {
	rval = ConnectivityManager.TETHER_ERROR_NO_ERROR;		rval = TETHER_ERROR_NO_ERROR;
	}		}
	}		}
	} finally {		} finally {
	@@ -477,7 +491,7 @@ public class Tethering extends BaseNetworkObserver {
	if (adapter == null \|\| !adapter.isEnabled()) {		if (adapter == null \|\| !adapter.isEnabled()) {
	Log.w(TAG, "Tried to enable bluetooth tethering with null or disabled adapter. null: " +		Log.w(TAG, "Tried to enable bluetooth tethering with null or disabled adapter. null: " +
	(adapter == null));		(adapter == null));
	sendTetherResult(receiver, ConnectivityManager.TETHER_ERROR_SERVICE_UNAVAIL);		sendTetherResult(receiver, TETHER_ERROR_SERVICE_UNAVAIL);
	return;		return;
	}		}

	@@ -490,12 +504,12 @@ public class Tethering extends BaseNetworkObserver {
	((BluetoothPan) proxy).setBluetoothTethering(enable);		((BluetoothPan) proxy).setBluetoothTethering(enable);
	// TODO: Enabling bluetooth tethering can fail asynchronously here.		// TODO: Enabling bluetooth tethering can fail asynchronously here.
	// We should figure out a way to bubble up that failure instead of sending success.		// We should figure out a way to bubble up that failure instead of sending success.
	int result = ((BluetoothPan) proxy).isTetheringOn() == enable ?		final int result = (((BluetoothPan) proxy).isTetheringOn() == enable)
	ConnectivityManager.TETHER_ERROR_NO_ERROR :		? TETHER_ERROR_NO_ERROR
	ConnectivityManager.TETHER_ERROR_MASTER_ERROR;		: TETHER_ERROR_MASTER_ERROR;
	sendTetherResult(receiver, result);		sendTetherResult(receiver, result);
	if (enable && isTetherProvisioningRequired()) {		if (enable && isTetherProvisioningRequired()) {
	scheduleProvisioningRechecks(ConnectivityManager.TETHERING_BLUETOOTH);		scheduleProvisioningRechecks(TETHERING_BLUETOOTH);
	}		}
	adapter.closeProfileProxy(BluetoothProfile.PAN, proxy);		adapter.closeProfileProxy(BluetoothProfile.PAN, proxy);
	}		}
	@@ -509,8 +523,8 @@ public class Tethering extends BaseNetworkObserver {

	private void sendUiTetherProvisionIntent(int type, ResultReceiver receiver) {		private void sendUiTetherProvisionIntent(int type, ResultReceiver receiver) {
	Intent intent = new Intent(Settings.ACTION_TETHER_PROVISIONING);		Intent intent = new Intent(Settings.ACTION_TETHER_PROVISIONING);
	intent.putExtra(ConnectivityManager.EXTRA_ADD_TETHER_TYPE, type);		intent.putExtra(EXTRA_ADD_TETHER_TYPE, type);
	intent.putExtra(ConnectivityManager.EXTRA_PROVISION_CALLBACK, receiver);		intent.putExtra(EXTRA_PROVISION_CALLBACK, receiver);
	intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);		intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
	final long ident = Binder.clearCallingIdentity();		final long ident = Binder.clearCallingIdentity();
	try {		try {
	@@ -533,7 +547,7 @@ public class Tethering extends BaseNetworkObserver {
	@Override		@Override
	protected void onReceiveResult(int resultCode, Bundle resultData) {		protected void onReceiveResult(int resultCode, Bundle resultData) {
	// If provisioning is successful, enable tethering, otherwise just send the error.		// If provisioning is successful, enable tethering, otherwise just send the error.
	if (resultCode == ConnectivityManager.TETHER_ERROR_NO_ERROR) {		if (resultCode == TETHER_ERROR_NO_ERROR) {
	enableTetheringInternal(type, true, receiver);		enableTetheringInternal(type, true, receiver);
	} else {		} else {
	sendTetherResult(receiver, resultCode);		sendTetherResult(receiver, resultCode);
	@@ -553,8 +567,8 @@ public class Tethering extends BaseNetworkObserver {

	private void scheduleProvisioningRechecks(int type) {		private void scheduleProvisioningRechecks(int type) {
	Intent intent = new Intent();		Intent intent = new Intent();
	intent.putExtra(ConnectivityManager.EXTRA_ADD_TETHER_TYPE, type);		intent.putExtra(EXTRA_ADD_TETHER_TYPE, type);
	intent.putExtra(ConnectivityManager.EXTRA_SET_ALARM, true);		intent.putExtra(EXTRA_SET_ALARM, true);
	intent.setComponent(TETHER_SERVICE);		intent.setComponent(TETHER_SERVICE);
	final long ident = Binder.clearCallingIdentity();		final long ident = Binder.clearCallingIdentity();
	try {		try {
	@@ -571,9 +585,9 @@ public class Tethering extends BaseNetworkObserver {

	private void sendSilentTetherProvisionIntent(int type, ResultReceiver receiver) {		private void sendSilentTetherProvisionIntent(int type, ResultReceiver receiver) {
	Intent intent = new Intent();		Intent intent = new Intent();
	intent.putExtra(ConnectivityManager.EXTRA_ADD_TETHER_TYPE, type);		intent.putExtra(EXTRA_ADD_TETHER_TYPE, type);
	intent.putExtra(ConnectivityManager.EXTRA_RUN_PROVISION, true);		intent.putExtra(EXTRA_RUN_PROVISION, true);
	intent.putExtra(ConnectivityManager.EXTRA_PROVISION_CALLBACK, receiver);		intent.putExtra(EXTRA_PROVISION_CALLBACK, receiver);
	intent.setComponent(TETHER_SERVICE);		intent.setComponent(TETHER_SERVICE);
	final long ident = Binder.clearCallingIdentity();		final long ident = Binder.clearCallingIdentity();
	try {		try {
	@@ -584,9 +598,9 @@ public class Tethering extends BaseNetworkObserver {
	}		}

	private void cancelTetherProvisioningRechecks(int type) {		private void cancelTetherProvisioningRechecks(int type) {
	if (getConnectivityManager().isTetheringSupported()) {		if (mDeps.isTetheringSupported()) {
	Intent intent = new Intent();		Intent intent = new Intent();
	intent.putExtra(ConnectivityManager.EXTRA_REM_TETHER_TYPE, type);		intent.putExtra(EXTRA_REM_TETHER_TYPE, type);
	intent.setComponent(TETHER_SERVICE);		intent.setComponent(TETHER_SERVICE);
	final long ident = Binder.clearCallingIdentity();		final long ident = Binder.clearCallingIdentity();
	try {		try {
	@@ -601,8 +615,8 @@ public class Tethering extends BaseNetworkObserver {
	// TODO: De-duplicate with above code, where possible.		// TODO: De-duplicate with above code, where possible.
	private void startProvisionIntent(int tetherType) {		private void startProvisionIntent(int tetherType) {
	final Intent startProvIntent = new Intent();		final Intent startProvIntent = new Intent();
	startProvIntent.putExtra(ConnectivityManager.EXTRA_ADD_TETHER_TYPE, tetherType);		startProvIntent.putExtra(EXTRA_ADD_TETHER_TYPE, tetherType);
	startProvIntent.putExtra(ConnectivityManager.EXTRA_RUN_PROVISION, true);		startProvIntent.putExtra(EXTRA_RUN_PROVISION, true);
	startProvIntent.setComponent(TETHER_SERVICE);		startProvIntent.setComponent(TETHER_SERVICE);
	mContext.startServiceAsUser(startProvIntent, UserHandle.CURRENT);		mContext.startServiceAsUser(startProvIntent, UserHandle.CURRENT);
	}		}
	@@ -617,13 +631,13 @@ public class Tethering extends BaseNetworkObserver {
	TetherState tetherState = mTetherStates.get(iface);		TetherState tetherState = mTetherStates.get(iface);
	if (tetherState == null) {		if (tetherState == null) {
	Log.e(TAG, "Tried to Tether an unknown iface: " + iface + ", ignoring");		Log.e(TAG, "Tried to Tether an unknown iface: " + iface + ", ignoring");
	return ConnectivityManager.TETHER_ERROR_UNKNOWN_IFACE;		return TETHER_ERROR_UNKNOWN_IFACE;
	}		}
	// Ignore the error status of the interface. If the interface is available,		// Ignore the error status of the interface. If the interface is available,
	// the errors are referring to past tethering attempts anyway.		// the errors are referring to past tethering attempts anyway.
	if (tetherState.lastState != IControlsTethering.STATE_AVAILABLE) {		if (tetherState.lastState != IControlsTethering.STATE_AVAILABLE) {
	Log.e(TAG, "Tried to Tether an unavailable iface: " + iface + ", ignoring");		Log.e(TAG, "Tried to Tether an unavailable iface: " + iface + ", ignoring");
	return ConnectivityManager.TETHER_ERROR_UNAVAIL_IFACE;		return TETHER_ERROR_UNAVAIL_IFACE;
	}		}
	// NOTE: If a CMD_TETHER_REQUESTED message is already in the TISM's		// NOTE: If a CMD_TETHER_REQUESTED message is already in the TISM's
	// queue but not yet processed, this will be a no-op and it will not		// queue but not yet processed, this will be a no-op and it will not
	@@ -632,7 +646,7 @@ public class Tethering extends BaseNetworkObserver {
	// TODO: reexamine the threading and messaging model.		// TODO: reexamine the threading and messaging model.
	tetherState.stateMachine.sendMessage(		tetherState.stateMachine.sendMessage(
	TetherInterfaceStateMachine.CMD_TETHER_REQUESTED, requestedState);		TetherInterfaceStateMachine.CMD_TETHER_REQUESTED, requestedState);
	return ConnectivityManager.TETHER_ERROR_NO_ERROR;		return TETHER_ERROR_NO_ERROR;
	}		}
	}		}

	@@ -642,22 +656,22 @@ public class Tethering extends BaseNetworkObserver {
	TetherState tetherState = mTetherStates.get(iface);		TetherState tetherState = mTetherStates.get(iface);
	if (tetherState == null) {		if (tetherState == null) {
	Log.e(TAG, "Tried to Untether an unknown iface :" + iface + ", ignoring");		Log.e(TAG, "Tried to Untether an unknown iface :" + iface + ", ignoring");
	return ConnectivityManager.TETHER_ERROR_UNKNOWN_IFACE;		return TETHER_ERROR_UNKNOWN_IFACE;
	}		}
	if (!tetherState.isCurrentlyServing()) {		if (!tetherState.isCurrentlyServing()) {
	Log.e(TAG, "Tried to untether an inactive iface :" + iface + ", ignoring");		Log.e(TAG, "Tried to untether an inactive iface :" + iface + ", ignoring");
	return ConnectivityManager.TETHER_ERROR_UNAVAIL_IFACE;		return TETHER_ERROR_UNAVAIL_IFACE;
	}		}
	tetherState.stateMachine.sendMessage(		tetherState.stateMachine.sendMessage(
	TetherInterfaceStateMachine.CMD_TETHER_UNREQUESTED);		TetherInterfaceStateMachine.CMD_TETHER_UNREQUESTED);
	return ConnectivityManager.TETHER_ERROR_NO_ERROR;		return TETHER_ERROR_NO_ERROR;
	}		}
	}		}

	public void untetherAll() {		public void untetherAll() {
	stopTethering(ConnectivityManager.TETHERING_WIFI);		stopTethering(TETHERING_WIFI);
	stopTethering(ConnectivityManager.TETHERING_USB);		stopTethering(TETHERING_USB);
	stopTethering(ConnectivityManager.TETHERING_BLUETOOTH);		stopTethering(TETHERING_BLUETOOTH);
	}		}

	public int getLastTetherError(String iface) {		public int getLastTetherError(String iface) {
	@@ -666,7 +680,7 @@ public class Tethering extends BaseNetworkObserver {
	if (tetherState == null) {		if (tetherState == null) {
	Log.e(TAG, "Tried to getLastTetherError on an unknown iface :" + iface +		Log.e(TAG, "Tried to getLastTetherError on an unknown iface :" + iface +
	", ignoring");		", ignoring");
	return ConnectivityManager.TETHER_ERROR_UNKNOWN_IFACE;		return TETHER_ERROR_UNKNOWN_IFACE;
	}		}
	return tetherState.lastError;		return tetherState.lastError;
	}		}
	@@ -674,7 +688,7 @@ public class Tethering extends BaseNetworkObserver {

	// TODO: Figure out how to update for local hotspot mode interfaces.		// TODO: Figure out how to update for local hotspot mode interfaces.
	private void sendTetherStateChangedBroadcast() {		private void sendTetherStateChangedBroadcast() {
	if (!getConnectivityManager().isTetheringSupported()) return;		if (!mDeps.isTetheringSupported()) return;

	final ArrayList<String> availableList = new ArrayList<>();		final ArrayList<String> availableList = new ArrayList<>();
	final ArrayList<String> tetherList = new ArrayList<>();		final ArrayList<String> tetherList = new ArrayList<>();
	@@ -691,7 +705,7 @@ public class Tethering extends BaseNetworkObserver {
	for (int i = 0; i < mTetherStates.size(); i++) {		for (int i = 0; i < mTetherStates.size(); i++) {
	TetherState tetherState = mTetherStates.valueAt(i);		TetherState tetherState = mTetherStates.valueAt(i);
	String iface = mTetherStates.keyAt(i);		String iface = mTetherStates.keyAt(i);
	if (tetherState.lastError != ConnectivityManager.TETHER_ERROR_NO_ERROR) {		if (tetherState.lastError != TETHER_ERROR_NO_ERROR) {
	erroredList.add(iface);		erroredList.add(iface);
	} else if (tetherState.lastState == IControlsTethering.STATE_AVAILABLE) {		} else if (tetherState.lastState == IControlsTethering.STATE_AVAILABLE) {
	availableList.add(iface);		availableList.add(iface);
	@@ -709,13 +723,13 @@ public class Tethering extends BaseNetworkObserver {
	}		}
	}		}
	}		}
	final Intent bcast = new Intent(ConnectivityManager.ACTION_TETHER_STATE_CHANGED);		final Intent bcast = new Intent(ACTION_TETHER_STATE_CHANGED);
	bcast.addFlags(Intent.FLAG_RECEIVER_REPLACE_PENDING \|		bcast.addFlags(Intent.FLAG_RECEIVER_REPLACE_PENDING \|
	Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);		Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
	bcast.putStringArrayListExtra(ConnectivityManager.EXTRA_AVAILABLE_TETHER, availableList);		bcast.putStringArrayListExtra(EXTRA_AVAILABLE_TETHER, availableList);
	bcast.putStringArrayListExtra(ConnectivityManager.EXTRA_ACTIVE_LOCAL_ONLY, localOnlyList);		bcast.putStringArrayListExtra(EXTRA_ACTIVE_LOCAL_ONLY, localOnlyList);
	bcast.putStringArrayListExtra(ConnectivityManager.EXTRA_ACTIVE_TETHER, tetherList);		bcast.putStringArrayListExtra(EXTRA_ACTIVE_TETHER, tetherList);
	bcast.putStringArrayListExtra(ConnectivityManager.EXTRA_ERRORED_TETHER, erroredList);		bcast.putStringArrayListExtra(EXTRA_ERRORED_TETHER, erroredList);
	mContext.sendStickyBroadcastAsUser(bcast, UserHandle.ALL);		mContext.sendStickyBroadcastAsUser(bcast, UserHandle.ALL);
	if (DBG) {		if (DBG) {
	Log.d(TAG, String.format(		Log.d(TAG, String.format(
	@@ -838,7 +852,7 @@ public class Tethering extends BaseNetworkObserver {

	if (action.equals(UsbManager.ACTION_USB_STATE)) {		if (action.equals(UsbManager.ACTION_USB_STATE)) {
	handleUsbAction(intent);		handleUsbAction(intent);
	} else if (action.equals(ConnectivityManager.CONNECTIVITY_ACTION)) {		} else if (action.equals(CONNECTIVITY_ACTION)) {
	handleConnectivityAction(intent);		handleConnectivityAction(intent);
	} else if (action.equals(WifiManager.WIFI_AP_STATE_CHANGED_ACTION)) {		} else if (action.equals(WifiManager.WIFI_AP_STATE_CHANGED_ACTION)) {
	handleWifiApAction(intent);		handleWifiApAction(intent);
	@@ -849,8 +863,8 @@ public class Tethering extends BaseNetworkObserver {
	}		}

	private void handleConnectivityAction(Intent intent) {		private void handleConnectivityAction(Intent intent) {
	final NetworkInfo networkInfo = (NetworkInfo)intent.getParcelableExtra(		final NetworkInfo networkInfo =
	ConnectivityManager.EXTRA_NETWORK_INFO);		(NetworkInfo) intent.getParcelableExtra(EXTRA_NETWORK_INFO);
	if (networkInfo == null \|\|		if (networkInfo == null \|\|
	networkInfo.getDetailedState() == NetworkInfo.DetailedState.FAILED) {		networkInfo.getDetailedState() == NetworkInfo.DetailedState.FAILED) {
	return;		return;
	@@ -886,14 +900,10 @@ public class Tethering extends BaseNetworkObserver {
	synchronized (Tethering.this.mPublicSync) {		synchronized (Tethering.this.mPublicSync) {
	if (!usbConnected && mRndisEnabled) {		if (!usbConnected && mRndisEnabled) {
	// Turn off tethering if it was enabled and there is a disconnect.		// Turn off tethering if it was enabled and there is a disconnect.
	tetherMatchingInterfaces(		tetherMatchingInterfaces(IControlsTethering.STATE_AVAILABLE, TETHERING_USB);
	IControlsTethering.STATE_AVAILABLE,
	ConnectivityManager.TETHERING_USB);
	} else if (usbConfigured && rndisEnabled) {		} else if (usbConfigured && rndisEnabled) {
	// Tether if rndis is enabled and usb is configured.		// Tether if rndis is enabled and usb is configured.
	tetherMatchingInterfaces(		tetherMatchingInterfaces(IControlsTethering.STATE_TETHERED, TETHERING_USB);
	IControlsTethering.STATE_TETHERED,
	ConnectivityManager.TETHERING_USB);
	}		}
	mRndisEnabled = usbConfigured && rndisEnabled;		mRndisEnabled = usbConfigured && rndisEnabled;
	}		}
	@@ -974,7 +984,7 @@ public class Tethering extends BaseNetworkObserver {

	for (int i = 0; i < mTetherStates.size(); i++) {		for (int i = 0; i < mTetherStates.size(); i++) {
	TetherInterfaceStateMachine tism = mTetherStates.valueAt(i).stateMachine;		TetherInterfaceStateMachine tism = mTetherStates.valueAt(i).stateMachine;
	if (tism.interfaceType() == ConnectivityManager.TETHERING_WIFI) {		if (tism.interfaceType() == TETHERING_WIFI) {
	tism.unwanted();		tism.unwanted();
	return;		return;
	}		}
	@@ -1002,7 +1012,7 @@ public class Tethering extends BaseNetworkObserver {
	}		}

	if (!TextUtils.isEmpty(ifname)) {		if (!TextUtils.isEmpty(ifname)) {
	maybeTrackNewInterfaceLocked(ifname, ConnectivityManager.TETHERING_WIFI);		maybeTrackNewInterfaceLocked(ifname, TETHERING_WIFI);
	changeInterfaceState(ifname, ipServingMode);		changeInterfaceState(ifname, ipServingMode);
	} else {		} else {
	mLog.e(String.format(		mLog.e(String.format(
	@@ -1061,7 +1071,7 @@ public class Tethering extends BaseNetworkObserver {
	Log.wtf(TAG, "Unknown interface state: " + requestedState);		Log.wtf(TAG, "Unknown interface state: " + requestedState);
	return;		return;
	}		}
	if (result != ConnectivityManager.TETHER_ERROR_NO_ERROR) {		if (result != TETHER_ERROR_NO_ERROR) {
	Log.e(TAG, "unable start or stop tethering on iface " + ifname);		Log.e(TAG, "unable start or stop tethering on iface " + ifname);
	return;		return;
	}		}
	@@ -1102,7 +1112,7 @@ public class Tethering extends BaseNetworkObserver {
	synchronized (mPublicSync) {		synchronized (mPublicSync) {
	usbManager.setCurrentFunction(enable ? UsbManager.USB_FUNCTION_RNDIS : null, false);		usbManager.setCurrentFunction(enable ? UsbManager.USB_FUNCTION_RNDIS : null, false);
	}		}
	return ConnectivityManager.TETHER_ERROR_NO_ERROR;		return TETHER_ERROR_NO_ERROR;
	}		}

	// TODO review API - figure out how to delete these entirely.		// TODO review API - figure out how to delete these entirely.
	@@ -1141,7 +1151,7 @@ public class Tethering extends BaseNetworkObserver {
	synchronized (mPublicSync) {		synchronized (mPublicSync) {
	for (int i = 0; i < mTetherStates.size(); i++) {		for (int i = 0; i < mTetherStates.size(); i++) {
	TetherState tetherState = mTetherStates.valueAt(i);		TetherState tetherState = mTetherStates.valueAt(i);
	if (tetherState.lastError != ConnectivityManager.TETHER_ERROR_NO_ERROR) {		if (tetherState.lastError != TETHER_ERROR_NO_ERROR) {
	list.add(mTetherStates.keyAt(i));		list.add(mTetherStates.keyAt(i));
	}		}
	}		}
	@@ -1187,7 +1197,7 @@ public class Tethering extends BaseNetworkObserver {
	}		}
	String iface = mTetherStates.keyAt(i);		String iface = mTetherStates.keyAt(i);
	int interfaceType = ifaceNameToType(iface);		int interfaceType = ifaceNameToType(iface);
	if (interfaceType != ConnectivityManager.TETHERING_INVALID) {		if (interfaceType != TETHERING_INVALID) {
	tethered.add(interfaceType);		tethered.add(interfaceType);
	}		}
	}		}
	@@ -1437,7 +1447,7 @@ public class Tethering extends BaseNetworkObserver {
	}		}

	// If this is a Wi-Fi interface, notify WifiManager of the active serving state.		// If this is a Wi-Fi interface, notify WifiManager of the active serving state.
	if (who.interfaceType() == ConnectivityManager.TETHERING_WIFI) {		if (who.interfaceType() == TETHERING_WIFI) {
	final WifiManager mgr = getWifiManager();		final WifiManager mgr = getWifiManager();
	final String iface = who.interfaceName();		final String iface = who.interfaceName();
	switch (mode) {		switch (mode) {
	@@ -1461,8 +1471,8 @@ public class Tethering extends BaseNetworkObserver {
	mForwardedDownstreams.remove(who);		mForwardedDownstreams.remove(who);

	// If this is a Wi-Fi interface, tell WifiManager of any errors.		// If this is a Wi-Fi interface, tell WifiManager of any errors.
	if (who.interfaceType() == ConnectivityManager.TETHERING_WIFI) {		if (who.interfaceType() == TETHERING_WIFI) {
	if (who.lastError() != ConnectivityManager.TETHER_ERROR_NO_ERROR) {		if (who.lastError() != TETHER_ERROR_NO_ERROR) {
	getWifiManager().updateInterfaceIpState(		getWifiManager().updateInterfaceIpState(
	who.interfaceName(), IFACE_IP_MODE_CONFIGURATION_ERROR);		who.interfaceName(), IFACE_IP_MODE_CONFIGURATION_ERROR);
	}		}
	@@ -1667,7 +1677,7 @@ public class Tethering extends BaseNetworkObserver {
	who.sendMessage(mErrorNotification);		who.sendMessage(mErrorNotification);
	break;		break;
	case CMD_CLEAR_ERROR:		case CMD_CLEAR_ERROR:
	mErrorNotification = ConnectivityManager.TETHER_ERROR_NO_ERROR;		mErrorNotification = TETHER_ERROR_NO_ERROR;
	transitionTo(mInitialState);		transitionTo(mInitialState);
	break;		break;
	default:		default:
	@@ -1929,7 +1939,7 @@ public class Tethering extends BaseNetworkObserver {
	// If TetherMasterSM is in ErrorState, TetherMasterSM stays there.		// If TetherMasterSM is in ErrorState, TetherMasterSM stays there.
	// Thus we give a chance for TetherMasterSM to recover to InitialState		// Thus we give a chance for TetherMasterSM to recover to InitialState
	// by sending CMD_CLEAR_ERROR		// by sending CMD_CLEAR_ERROR
	if (error == ConnectivityManager.TETHER_ERROR_MASTER_ERROR) {		if (error == TETHER_ERROR_MASTER_ERROR) {
	mTetherMasterSM.sendMessage(TetherMasterSM.CMD_CLEAR_ERROR, who);		mTetherMasterSM.sendMessage(TetherMasterSM.CMD_CLEAR_ERROR, who);
	}		}
	int which;		int which;
	@@ -1973,7 +1983,7 @@ public class Tethering extends BaseNetworkObserver {
	private void maybeTrackNewInterfaceLocked(final String iface) {		private void maybeTrackNewInterfaceLocked(final String iface) {
	// If we don't care about this type of interface, ignore.		// If we don't care about this type of interface, ignore.
	final int interfaceType = ifaceNameToType(iface);		final int interfaceType = ifaceNameToType(iface);
	if (interfaceType == ConnectivityManager.TETHERING_INVALID) {		if (interfaceType == TETHERING_INVALID) {
	mLog.log(iface + " is not a tetherable iface, ignoring");		mLog.log(iface + " is not a tetherable iface, ignoring");
	return;		return;
	}		}

services/core/java/com/android/server/connectivity/tethering/TetheringDependencies.java

+4 −0

Original line number	Original line	Diff line number	Diff line
	@@ -60,4 +60,8 @@ public class TetheringDependencies {
	public INetd getNetdService() {		public INetd getNetdService() {
	return NetdService.getInstance();		return NetdService.getInstance();
	}		}

			public boolean isTetheringSupported() {
			return true;
			}
	}		}