Merge "ConnectivityManager: allow usage of TYPE_NONE" (0537f165) · Commits · e / os / android_frameworks_base

core/java/android/net/ConnectivityManager.java

+5 −1

Original line number	Original line	Diff line number	Diff line
	@@ -582,6 +582,8 @@ public class ConnectivityManager {
	/** {@hide} */		/** {@hide} */
	public static final int MAX_NETWORK_TYPE = TYPE_VPN;		public static final int MAX_NETWORK_TYPE = TYPE_VPN;

			private static final int MIN_NETWORK_TYPE = TYPE_MOBILE;

	/**		/**
	* If you want to set the default network preference,you can directly		* If you want to set the default network preference,you can directly
	* change the networkAttributes array in framework's config.xml.		* change the networkAttributes array in framework's config.xml.
	@@ -640,7 +642,7 @@ public class ConnectivityManager {
	*/		*/
	@Deprecated		@Deprecated
	public static boolean isNetworkTypeValid(int networkType) {		public static boolean isNetworkTypeValid(int networkType) {
	return networkType >= 0 && networkType <= MAX_NETWORK_TYPE;		return MIN_NETWORK_TYPE <= networkType && networkType <= MAX_NETWORK_TYPE;
	}		}

	/**		/**
	@@ -653,6 +655,8 @@ public class ConnectivityManager {
	*/		*/
	public static String getNetworkTypeName(int type) {		public static String getNetworkTypeName(int type) {
	switch (type) {		switch (type) {
			case TYPE_NONE:
			return "NONE";
	case TYPE_MOBILE:		case TYPE_MOBILE:
	return "MOBILE";		return "MOBILE";
	case TYPE_WIFI:		case TYPE_WIFI:

core/java/android/net/NetworkCapabilities.java

+15 −11

Original line number	Original line	Diff line number	Diff line
	@@ -21,6 +21,7 @@ import android.os.Parcelable;

	import com.android.internal.annotations.VisibleForTesting;		import com.android.internal.annotations.VisibleForTesting;
	import com.android.internal.util.BitUtils;		import com.android.internal.util.BitUtils;
			import com.android.internal.util.Preconditions;

	import java.util.Objects;		import java.util.Objects;

	@@ -423,6 +424,11 @@ public final class NetworkCapabilities implements Parcelable {
	/** @hide */		/** @hide */
	public static final int MAX_TRANSPORT = TRANSPORT_WIFI_AWARE;		public static final int MAX_TRANSPORT = TRANSPORT_WIFI_AWARE;

			/** @hide */
			public static boolean isValidTransport(int transportType) {
			return (MIN_TRANSPORT <= transportType) && (transportType <= MAX_TRANSPORT);
			}

	private static final String[] TRANSPORT_NAMES = {		private static final String[] TRANSPORT_NAMES = {
	"CELLULAR",		"CELLULAR",
	"WIFI",		"WIFI",
	@@ -446,9 +452,7 @@ public final class NetworkCapabilities implements Parcelable {
	* @hide		* @hide
	*/		*/
	public NetworkCapabilities addTransportType(int transportType) {		public NetworkCapabilities addTransportType(int transportType) {
	if (transportType < MIN_TRANSPORT \|\| transportType > MAX_TRANSPORT) {		checkValidTransportType(transportType);
	throw new IllegalArgumentException("TransportType out of range");
	}
	mTransportTypes \|= 1 << transportType;		mTransportTypes \|= 1 << transportType;
	setNetworkSpecifier(mNetworkSpecifier); // used for exception checking		setNetworkSpecifier(mNetworkSpecifier); // used for exception checking
	return this;		return this;
	@@ -462,9 +466,7 @@ public final class NetworkCapabilities implements Parcelable {
	* @hide		* @hide
	*/		*/
	public NetworkCapabilities removeTransportType(int transportType) {		public NetworkCapabilities removeTransportType(int transportType) {
	if (transportType < MIN_TRANSPORT \|\| transportType > MAX_TRANSPORT) {		checkValidTransportType(transportType);
	throw new IllegalArgumentException("TransportType out of range");
	}
	mTransportTypes &= ~(1 << transportType);		mTransportTypes &= ~(1 << transportType);
	setNetworkSpecifier(mNetworkSpecifier); // used for exception checking		setNetworkSpecifier(mNetworkSpecifier); // used for exception checking
	return this;		return this;
	@@ -488,10 +490,7 @@ public final class NetworkCapabilities implements Parcelable {
	* @return {@code true} if set on this instance.		* @return {@code true} if set on this instance.
	*/		*/
	public boolean hasTransport(int transportType) {		public boolean hasTransport(int transportType) {
	if (transportType < MIN_TRANSPORT \|\| transportType > MAX_TRANSPORT) {		return isValidTransport(transportType) && ((mTransportTypes & (1 << transportType)) != 0);
	return false;
	}
	return ((mTransportTypes & (1 << transportType)) != 0);
	}		}

	private void combineTransportTypes(NetworkCapabilities nc) {		private void combineTransportTypes(NetworkCapabilities nc) {
	@@ -899,9 +898,14 @@ public final class NetworkCapabilities implements Parcelable {
	* @hide		* @hide
	*/		*/
	public static String transportNameOf(int transport) {		public static String transportNameOf(int transport) {
	if (transport < 0 \|\| TRANSPORT_NAMES.length <= transport) {		if (!isValidTransport(transport)) {
	return "UNKNOWN";		return "UNKNOWN";
	}		}
	return TRANSPORT_NAMES[transport];		return TRANSPORT_NAMES[transport];
	}		}

			private static void checkValidTransportType(int transport) {
			Preconditions.checkArgument(
			isValidTransport(transport), "Invalid TransportType " + transport);
			}
	}		}

core/java/android/net/NetworkInfo.java

+2 −1

Original line number	Original line	Diff line number	Diff line
	@@ -127,7 +127,8 @@ public class NetworkInfo implements Parcelable {
	* @hide		* @hide
	*/		*/
	public NetworkInfo(int type, int subtype, String typeName, String subtypeName) {		public NetworkInfo(int type, int subtype, String typeName, String subtypeName) {
	if (!ConnectivityManager.isNetworkTypeValid(type)) {		if (!ConnectivityManager.isNetworkTypeValid(type)
			&& type != ConnectivityManager.TYPE_NONE) {
	throw new IllegalArgumentException("Invalid network type: " + type);		throw new IllegalArgumentException("Invalid network type: " + type);
	}		}
	mNetworkType = type;		mNetworkType = type;

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

+3 −0

Original line number	Original line	Diff line number	Diff line
	@@ -3784,6 +3784,9 @@ public class ConnectivityService extends IConnectivityManager.Stub
	public void setProvisioningNotificationVisible(boolean visible, int networkType,		public void setProvisioningNotificationVisible(boolean visible, int networkType,
	String action) {		String action) {
	enforceConnectivityInternalPermission();		enforceConnectivityInternalPermission();
			if (!ConnectivityManager.isNetworkTypeValid(networkType)) {
			return;
			}
	final long ident = Binder.clearCallingIdentity();		final long ident = Binder.clearCallingIdentity();
	try {		try {
	// Concatenate the range of types onto the range of NetIDs.		// Concatenate the range of types onto the range of NetIDs.

tests/net/java/com/android/server/ConnectivityServiceTest.java

+131 −25

Original line number	Original line	Diff line number	Diff line
	@@ -19,6 +19,7 @@ package com.android.server;
	import static android.net.ConnectivityManager.CONNECTIVITY_ACTION;		import static android.net.ConnectivityManager.CONNECTIVITY_ACTION;
	import static android.net.ConnectivityManager.TYPE_ETHERNET;		import static android.net.ConnectivityManager.TYPE_ETHERNET;
	import static android.net.ConnectivityManager.TYPE_MOBILE;		import static android.net.ConnectivityManager.TYPE_MOBILE;
			import static android.net.ConnectivityManager.TYPE_NONE;
	import static android.net.ConnectivityManager.TYPE_WIFI;		import static android.net.ConnectivityManager.TYPE_WIFI;
	import static android.net.ConnectivityManager.getNetworkTypeName;		import static android.net.ConnectivityManager.getNetworkTypeName;
	import static android.net.NetworkCapabilities.*;		import static android.net.NetworkCapabilities.*;
	@@ -114,6 +115,7 @@ import java.util.concurrent.LinkedBlockingQueue;
	import java.util.concurrent.TimeUnit;		import java.util.concurrent.TimeUnit;
	import java.util.concurrent.atomic.AtomicBoolean;		import java.util.concurrent.atomic.AtomicBoolean;
	import java.util.function.BooleanSupplier;		import java.util.function.BooleanSupplier;
			import java.util.function.Predicate;

	/**		/**
	* Tests for {@link ConnectivityService}.		* Tests for {@link ConnectivityService}.
	@@ -317,6 +319,9 @@ public class ConnectivityServiceTest extends AndroidTestCase {
	case TRANSPORT_CELLULAR:		case TRANSPORT_CELLULAR:
	mScore = 50;		mScore = 50;
	break;		break;
			case TRANSPORT_WIFI_AWARE:
			mScore = 20;
			break;
	default:		default:
	throw new UnsupportedOperationException("unimplemented network type");		throw new UnsupportedOperationException("unimplemented network type");
	}		}
	@@ -398,6 +403,15 @@ public class ConnectivityServiceTest extends AndroidTestCase {
	* @param validated Indicate if network should pretend to be validated.		* @param validated Indicate if network should pretend to be validated.
	*/		*/
	public void connect(boolean validated) {		public void connect(boolean validated) {
			connect(validated, true);
			}

			/**
			* Transition this NetworkAgent to CONNECTED state.
			* @param validated Indicate if network should pretend to be validated.
			* @param hasInternet Indicate if network should pretend to have NET_CAPABILITY_INTERNET.
			*/
			public void connect(boolean validated, boolean hasInternet) {
	assertEquals("MockNetworkAgents can only be connected once",		assertEquals("MockNetworkAgents can only be connected once",
	mNetworkInfo.getDetailedState(), DetailedState.IDLE);		mNetworkInfo.getDetailedState(), DetailedState.IDLE);
	assertFalse(mNetworkCapabilities.hasCapability(NET_CAPABILITY_INTERNET));		assertFalse(mNetworkCapabilities.hasCapability(NET_CAPABILITY_INTERNET));
	@@ -420,7 +434,9 @@ public class ConnectivityServiceTest extends AndroidTestCase {
	};		};
	mCm.registerNetworkCallback(request, callback);		mCm.registerNetworkCallback(request, callback);
	}		}
			if (hasInternet) {
	addCapability(NET_CAPABILITY_INTERNET);		addCapability(NET_CAPABILITY_INTERNET);
			}

	connectWithoutInternet();		connectWithoutInternet();

	@@ -774,7 +790,10 @@ public class ConnectivityServiceTest extends AndroidTestCase {
	* Fails if TIMEOUT_MS goes by before {@code conditionVariable} opens.		* Fails if TIMEOUT_MS goes by before {@code conditionVariable} opens.
	*/		*/
	static private void waitFor(ConditionVariable conditionVariable) {		static private void waitFor(ConditionVariable conditionVariable) {
	assertTrue(conditionVariable.block(TIMEOUT_MS));		if (conditionVariable.block(TIMEOUT_MS)) {
			return;
			}
			fail("ConditionVariable was blocked for more than " + TIMEOUT_MS + "ms");
	}		}

	@Override		@Override
	@@ -832,7 +851,7 @@ public class ConnectivityServiceTest extends AndroidTestCase {
	case TRANSPORT_CELLULAR:		case TRANSPORT_CELLULAR:
	return TYPE_MOBILE;		return TYPE_MOBILE;
	default:		default:
	throw new IllegalStateException("Unknown transport " + transport);		return TYPE_NONE;
	}		}
	}		}

	@@ -843,6 +862,9 @@ public class ConnectivityServiceTest extends AndroidTestCase {
	// Test getActiveNetwork()		// Test getActiveNetwork()
	assertNotNull(mCm.getActiveNetwork());		assertNotNull(mCm.getActiveNetwork());
	assertEquals(mCm.getActiveNetwork(), mCm.getActiveNetworkForUid(Process.myUid()));		assertEquals(mCm.getActiveNetwork(), mCm.getActiveNetworkForUid(Process.myUid()));
			if (!NetworkCapabilities.isValidTransport(transport)) {
			throw new IllegalStateException("Unknown transport " + transport);
			}
	switch (transport) {		switch (transport) {
	case TRANSPORT_WIFI:		case TRANSPORT_WIFI:
	assertEquals(mCm.getActiveNetwork(), mWiFiNetworkAgent.getNetwork());		assertEquals(mCm.getActiveNetwork(), mWiFiNetworkAgent.getNetwork());
	@@ -851,7 +873,7 @@ public class ConnectivityServiceTest extends AndroidTestCase {
	assertEquals(mCm.getActiveNetwork(), mCellNetworkAgent.getNetwork());		assertEquals(mCm.getActiveNetwork(), mCellNetworkAgent.getNetwork());
	break;		break;
	default:		default:
	throw new IllegalStateException("Unknown transport" + transport);		break;
	}		}
	// Test getNetworkInfo(Network)		// Test getNetworkInfo(Network)
	assertNotNull(mCm.getNetworkInfo(mCm.getActiveNetwork()));		assertNotNull(mCm.getNetworkInfo(mCm.getActiveNetwork()));
	@@ -1271,7 +1293,26 @@ public class ConnectivityServiceTest extends AndroidTestCase {
	return expectCallback(state, agent, TIMEOUT_MS);		return expectCallback(state, agent, TIMEOUT_MS);
	}		}

	void expectAvailableCallbacks(MockNetworkAgent agent, boolean expectSuspended, int timeoutMs) {		CallbackInfo expectCallbackLike(Predicate<CallbackInfo> fn) {
			return expectCallbackLike(fn, TIMEOUT_MS);
			}

			CallbackInfo expectCallbackLike(Predicate<CallbackInfo> fn, int timeoutMs) {
			int timeLeft = timeoutMs;
			while (timeLeft > 0) {
			long start = SystemClock.elapsedRealtime();
			CallbackInfo info = nextCallback(timeLeft);
			if (fn.test(info)) {
			return info;
			}
			timeLeft -= (SystemClock.elapsedRealtime() - start);
			}
			fail("Did not receive expected callback after " + timeoutMs + "ms");
			return null;
			}

			void expectAvailableCallbacks(
			MockNetworkAgent agent, boolean expectSuspended, int timeoutMs) {
	expectCallback(CallbackState.AVAILABLE, agent, timeoutMs);		expectCallback(CallbackState.AVAILABLE, agent, timeoutMs);
	if (expectSuspended) {		if (expectSuspended) {
	expectCallback(CallbackState.SUSPENDED, agent, timeoutMs);		expectCallback(CallbackState.SUSPENDED, agent, timeoutMs);
	@@ -1828,26 +1869,18 @@ public class ConnectivityServiceTest extends AndroidTestCase {
	@SmallTest		@SmallTest
	public void testNoMutableNetworkRequests() throws Exception {		public void testNoMutableNetworkRequests() throws Exception {
	PendingIntent pendingIntent = PendingIntent.getBroadcast(mContext, 0, new Intent("a"), 0);		PendingIntent pendingIntent = PendingIntent.getBroadcast(mContext, 0, new Intent("a"), 0);
	NetworkRequest.Builder builder = new NetworkRequest.Builder();		NetworkRequest request1 = new NetworkRequest.Builder()
	builder.addCapability(NET_CAPABILITY_VALIDATED);		.addCapability(NET_CAPABILITY_VALIDATED)
	try {		.build();
	mCm.requestNetwork(builder.build(), new NetworkCallback());		NetworkRequest request2 = new NetworkRequest.Builder()
	fail();		.addCapability(NET_CAPABILITY_CAPTIVE_PORTAL)
	} catch (IllegalArgumentException expected) {}		.build();
	try {
	mCm.requestNetwork(builder.build(), pendingIntent);		Class<IllegalArgumentException> expected = IllegalArgumentException.class;
	fail();		assertException(() -> { mCm.requestNetwork(request1, new NetworkCallback()); }, expected);
	} catch (IllegalArgumentException expected) {}		assertException(() -> { mCm.requestNetwork(request1, pendingIntent); }, expected);
	builder = new NetworkRequest.Builder();		assertException(() -> { mCm.requestNetwork(request2, new NetworkCallback()); }, expected);
	builder.addCapability(NET_CAPABILITY_CAPTIVE_PORTAL);		assertException(() -> { mCm.requestNetwork(request2, pendingIntent); }, expected);
	try {
	mCm.requestNetwork(builder.build(), new NetworkCallback());
	fail();
	} catch (IllegalArgumentException expected) {}
	try {
	mCm.requestNetwork(builder.build(), pendingIntent);
	fail();
	} catch (IllegalArgumentException expected) {}
	}		}

	@SmallTest		@SmallTest
	@@ -3243,6 +3276,67 @@ public class ConnectivityServiceTest extends AndroidTestCase {
	}		}
	}		}

			@SmallTest
			public void testNetworkInfoOfTypeNone() {
			ConditionVariable broadcastCV = waitForConnectivityBroadcasts(1);

			verifyNoNetwork();
			MockNetworkAgent lowpanNetwork = new MockNetworkAgent(TRANSPORT_WIFI_AWARE);
			assertNull(mCm.getActiveNetworkInfo());

			Network[] allNetworks = mCm.getAllNetworks();
			assertLength(1, allNetworks);
			Network network = allNetworks[0];
			NetworkCapabilities capabilities = mCm.getNetworkCapabilities(network);
			assertTrue(capabilities.hasTransport(TRANSPORT_WIFI_AWARE));

			final NetworkRequest request =
			new NetworkRequest.Builder().addTransportType(TRANSPORT_WIFI_AWARE).build();
			final TestNetworkCallback callback = new TestNetworkCallback();
			mCm.registerNetworkCallback(request, callback);

			// Bring up lowpan.
			lowpanNetwork.connect(false, false);
			callback.expectAvailableCallbacks(lowpanNetwork);

			assertNull(mCm.getActiveNetworkInfo());
			assertNull(mCm.getActiveNetwork());
			// TODO: getAllNetworkInfo is dirty and returns a non-empty array rght from the start
			// of this test. Fix it and uncomment the assert below.
			//assertEmpty(mCm.getAllNetworkInfo());

			// Disconnect lowpan.
			lowpanNetwork.disconnect();
			callback.expectCallback(CallbackState.LOST, lowpanNetwork);
			mCm.unregisterNetworkCallback(callback);

			verifyNoNetwork();
			if (broadcastCV.block(10)) {
			fail("expected no broadcast, but got CONNECTIVITY_ACTION broadcast");
			}
			}

			@SmallTest
			public void testDeprecatedAndUnsupportedOperations() throws Exception {
			final int TYPE_NONE = ConnectivityManager.TYPE_NONE;
			assertNull(mCm.getNetworkInfo(TYPE_NONE));
			assertNull(mCm.getNetworkForType(TYPE_NONE));
			assertNull(mCm.getLinkProperties(TYPE_NONE));
			assertFalse(mCm.isNetworkSupported(TYPE_NONE));

			assertException(() -> { mCm.networkCapabilitiesForType(TYPE_NONE); },
			IllegalArgumentException.class);

			Class<UnsupportedOperationException> unsupported = UnsupportedOperationException.class;
			assertException(() -> { mCm.startUsingNetworkFeature(TYPE_WIFI, ""); }, unsupported);
			assertException(() -> { mCm.stopUsingNetworkFeature(TYPE_WIFI, ""); }, unsupported);
			// TODO: let test context have configuration application target sdk version
			// and test that pre-M requesting for TYPE_NONE sends back APN_REQUEST_FAILED
			assertException(() -> { mCm.startUsingNetworkFeature(TYPE_NONE, ""); }, unsupported);
			assertException(() -> { mCm.stopUsingNetworkFeature(TYPE_NONE, ""); }, unsupported);
			assertException(() -> { mCm.requestRouteToHostAddress(TYPE_NONE, null); }, unsupported);
			}

	private static <T> void assertEmpty(T[] ts) {		private static <T> void assertEmpty(T[] ts) {
	int length = ts.length;		int length = ts.length;
	assertEquals("expected empty array, but length was " + length, 0, length);		assertEquals("expected empty array, but length was " + length, 0, length);
	@@ -3253,4 +3347,16 @@ public class ConnectivityServiceTest extends AndroidTestCase {
	assertEquals(String.format("expected array of length %s, but length was %s for %s",		assertEquals(String.format("expected array of length %s, but length was %s for %s",
	expected, length, Arrays.toString(got)), expected, length);		expected, length, Arrays.toString(got)), expected, length);
	}		}

			private static <T> void assertException(Runnable block, Class<T> expected) {
			try {
			block.run();
			fail("Expected exception of type " + expected);
			} catch (Exception got) {
			if (!got.getClass().equals(expected)) {
			fail("Expected exception of type " + expected + " but got " + got);
			}
			return;
			}
			}
	}		}