LineageOS/android_packages_modules_Connectivity
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Do callback unregistration automatically in tearDown am: 7a45f107de

Browse Source 
Original change: https://android-review.googlesource.com/c/platform/packages/modules/Connectivity/+/1787229

Change-Id: I9b2c27c6ebe2c64c95a921a5bdc363e5d8b92e43
This commit is contained in:
Chiachang Wang
2021-08-05 14:02:11 +00:00
committed by Automerger Merge Worker
parent 9e6b732a17 7a45f107de
commit 4e0841524b
1 changed files with 124 additions and 128 deletions
Download Patch File Download Diff File Expand all files Collapse all files

252
tests/cts/net/src/android/net/cts/ConnectivityManagerTest.java
View File

@@ -282,7 +282,8 @@ public class ConnectivityManagerTest {
private final ArraySet<Integer> mNetworkTypes = new ArraySet<>(); private final ArraySet<Integer> mNetworkTypes = new ArraySet<>();
private UiAutomation mUiAutomation; private UiAutomation mUiAutomation;
private CtsNetUtils mCtsNetUtils; private CtsNetUtils mCtsNetUtils;
// The registered callbacks.
private List<NetworkCallback> mRegisteredCallbacks = new ArrayList<>();
// Used for cleanup purposes. // Used for cleanup purposes.
private final List<Range<Integer>> mVpnRequiredUidRanges = new ArrayList<>(); private final List<Range<Integer>> mVpnRequiredUidRanges = new ArrayList<>();
@@ -377,11 +378,12 @@ public class ConnectivityManagerTest {
// All tests in this class require a working Internet connection as they start. Make // All tests in this class require a working Internet connection as they start. Make
// sure there is still one as they end that's ready to use for the next test to use. // sure there is still one as they end that's ready to use for the next test to use.
final TestNetworkCallback callback = new TestNetworkCallback(); final TestNetworkCallback callback = new TestNetworkCallback();
mCm.registerDefaultNetworkCallback(callback); registerDefaultNetworkCallback(callback);
try { try {
assertNotNull("Couldn't restore Internet connectivity", callback.waitForAvailable()); assertNotNull("Couldn't restore Internet connectivity", callback.waitForAvailable());
} finally { } finally {
unregisterCallbackQuietly(callback); // Unregister all registered callbacks.
unregisterRegisteredCallbacks();
} }
} }
@@ -716,7 +718,7 @@ public class ConnectivityManagerTest {
final String goodPrivateDnsServer = "dns.google"; final String goodPrivateDnsServer = "dns.google";
mCtsNetUtils.storePrivateDnsSetting(); mCtsNetUtils.storePrivateDnsSetting();
final TestableNetworkCallback cb = new TestableNetworkCallback(); final TestableNetworkCallback cb = new TestableNetworkCallback();
mCm.registerNetworkCallback(makeWifiNetworkRequest(), cb); registerNetworkCallback(makeWifiNetworkRequest(), cb);
try { try {
// Verifying the good private DNS sever // Verifying the good private DNS sever
mCtsNetUtils.setPrivateDnsStrictMode(goodPrivateDnsServer); mCtsNetUtils.setPrivateDnsStrictMode(goodPrivateDnsServer);
@@ -748,15 +750,15 @@ public class ConnectivityManagerTest {
*/ */
@AppModeFull(reason = "Cannot get WifiManager in instant app mode") @AppModeFull(reason = "Cannot get WifiManager in instant app mode")
@Test @Test
public void testRegisterNetworkCallback() { public void testRegisterNetworkCallback() throws Exception {
assumeTrue(mPackageManager.hasSystemFeature(FEATURE_WIFI)); assumeTrue(mPackageManager.hasSystemFeature(FEATURE_WIFI));
// We will register for a WIFI network being available or lost. // We will register for a WIFI network being available or lost.
final TestNetworkCallback callback = new TestNetworkCallback(); final TestNetworkCallback callback = new TestNetworkCallback();
mCm.registerNetworkCallback(makeWifiNetworkRequest(), callback); registerNetworkCallback(makeWifiNetworkRequest(), callback);
final TestNetworkCallback defaultTrackingCallback = new TestNetworkCallback(); final TestNetworkCallback defaultTrackingCallback = new TestNetworkCallback();
mCm.registerDefaultNetworkCallback(defaultTrackingCallback); registerDefaultNetworkCallback(defaultTrackingCallback);
final TestNetworkCallback systemDefaultCallback = new TestNetworkCallback(); final TestNetworkCallback systemDefaultCallback = new TestNetworkCallback();
final TestNetworkCallback perUidCallback = new TestNetworkCallback(); final TestNetworkCallback perUidCallback = new TestNetworkCallback();
@@ -764,51 +766,37 @@ public class ConnectivityManagerTest {
final Handler h = new Handler(Looper.getMainLooper()); final Handler h = new Handler(Looper.getMainLooper());
if (TestUtils.shouldTestSApis()) { if (TestUtils.shouldTestSApis()) {
runWithShellPermissionIdentity(() -> { runWithShellPermissionIdentity(() -> {
mCmShim.registerSystemDefaultNetworkCallback(systemDefaultCallback, h); registerSystemDefaultNetworkCallback(systemDefaultCallback, h);
mCmShim.registerDefaultNetworkCallbackForUid(Process.myUid(), perUidCallback, h); registerDefaultNetworkCallbackForUid(Process.myUid(), perUidCallback, h);
}, NETWORK_SETTINGS); }, NETWORK_SETTINGS);
mCm.registerBestMatchingNetworkCallback(makeDefaultRequest(), bestMatchingCallback, h); registerBestMatchingNetworkCallback(makeDefaultRequest(), bestMatchingCallback, h);
} }
Network wifiNetwork = null; Network wifiNetwork = null;
mCtsNetUtils.ensureWifiConnected();
try { // Now we should expect to get a network callback about availability of the wifi
mCtsNetUtils.ensureWifiConnected(); // network even if it was already connected as a state-based action when the callback
// is registered.
wifiNetwork = callback.waitForAvailable();
assertNotNull("Did not receive onAvailable for TRANSPORT_WIFI request",
wifiNetwork);
// Now we should expect to get a network callback about availability of the wifi final Network defaultNetwork = defaultTrackingCallback.waitForAvailable();
// network even if it was already connected as a state-based action when the callback assertNotNull("Did not receive onAvailable on default network callback",
// is registered. defaultNetwork);
wifiNetwork = callback.waitForAvailable();
assertNotNull("Did not receive onAvailable for TRANSPORT_WIFI request",
wifiNetwork);
final Network defaultNetwork = defaultTrackingCallback.waitForAvailable(); if (TestUtils.shouldTestSApis()) {
assertNotNull("Did not receive onAvailable on default network callback", assertNotNull("Did not receive onAvailable on system default network callback",
defaultNetwork); systemDefaultCallback.waitForAvailable());
final Network perUidNetwork = perUidCallback.waitForAvailable();
if (TestUtils.shouldTestSApis()) { assertNotNull("Did not receive onAvailable on per-UID default network callback",
assertNotNull("Did not receive onAvailable on system default network callback", perUidNetwork);
systemDefaultCallback.waitForAvailable()); assertEquals(defaultNetwork, perUidNetwork);
final Network perUidNetwork = perUidCallback.waitForAvailable(); final Network bestMatchingNetwork = bestMatchingCallback.waitForAvailable();
assertNotNull("Did not receive onAvailable on per-UID default network callback", assertNotNull("Did not receive onAvailable on best matching network callback",
perUidNetwork); bestMatchingNetwork);
assertEquals(defaultNetwork, perUidNetwork); assertEquals(defaultNetwork, bestMatchingNetwork);
final Network bestMatchingNetwork = bestMatchingCallback.waitForAvailable();
assertNotNull("Did not receive onAvailable on best matching network callback",
bestMatchingNetwork);
assertEquals(defaultNetwork, bestMatchingNetwork);
}
} catch (InterruptedException e) {
fail("Broadcast receiver or NetworkCallback wait was interrupted.");
} finally {
unregisterCallbackQuietly(callback);
unregisterCallbackQuietly(defaultTrackingCallback);
if (TestUtils.shouldTestSApis()) {
unregisterCallbackQuietly(systemDefaultCallback);
unregisterCallbackQuietly(perUidCallback);
unregisterCallbackQuietly(bestMatchingCallback);
}
} }
} }
@@ -979,22 +967,15 @@ public class ConnectivityManagerTest {
*/ */
@AppModeFull(reason = "CHANGE_NETWORK_STATE permission can't be granted to instant apps") @AppModeFull(reason = "CHANGE_NETWORK_STATE permission can't be granted to instant apps")
@Test @Test
public void testRequestNetworkCallback() { public void testRequestNetworkCallback() throws Exception {
final TestNetworkCallback callback = new TestNetworkCallback(); final TestNetworkCallback callback = new TestNetworkCallback();
mCm.requestNetwork(new NetworkRequest.Builder() requestNetwork(new NetworkRequest.Builder()
.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
.build(), callback); .build(), callback);
try { // Wait to get callback for availability of internet
// Wait to get callback for availability of internet Network internetNetwork = callback.waitForAvailable();
Network internetNetwork = callback.waitForAvailable(); assertNotNull("Did not receive NetworkCallback#onAvailable for INTERNET", internetNetwork);
assertNotNull("Did not receive NetworkCallback#onAvailable for INTERNET",
internetNetwork);
} catch (InterruptedException e) {
fail("NetworkCallback wait was interrupted.");
} finally {
unregisterCallbackQuietly(callback);
}
} }
/** /**
@@ -1010,9 +991,8 @@ public class ConnectivityManagerTest {
} }
final TestNetworkCallback callback = new TestNetworkCallback(); final TestNetworkCallback callback = new TestNetworkCallback();
mCm.requestNetwork(new NetworkRequest.Builder() requestNetwork(new NetworkRequest.Builder().addTransportType(TRANSPORT_WIFI).build(),
.addTransportType(TRANSPORT_WIFI) callback, 100);
.build(), callback, 100);
try { try {
// Wait to get callback for unavailability of requested network // Wait to get callback for unavailability of requested network
@@ -1021,7 +1001,6 @@ public class ConnectivityManagerTest {
} catch (InterruptedException e) { } catch (InterruptedException e) {
fail("NetworkCallback wait was interrupted."); fail("NetworkCallback wait was interrupted.");
} finally { } finally {
unregisterCallbackQuietly(callback);
if (previousWifiEnabledState) { if (previousWifiEnabledState) {
mCtsNetUtils.connectToWifi(); mCtsNetUtils.connectToWifi();
} }
@@ -1124,11 +1103,11 @@ public class ConnectivityManagerTest {
// this method will return right away, and if not, it'll wait for the setting to change. // this method will return right away, and if not, it'll wait for the setting to change.
if (useSystemDefault) { if (useSystemDefault) {
runWithShellPermissionIdentity(() -> runWithShellPermissionIdentity(() ->
mCmShim.registerSystemDefaultNetworkCallback(networkCallback, registerSystemDefaultNetworkCallback(networkCallback,
new Handler(Looper.getMainLooper())), new Handler(Looper.getMainLooper())),
NETWORK_SETTINGS); NETWORK_SETTINGS);
} else { } else {
mCm.registerDefaultNetworkCallback(networkCallback); registerDefaultNetworkCallback(networkCallback);
} }
// Changing meteredness on wifi involves reconnecting, which can take several seconds // Changing meteredness on wifi involves reconnecting, which can take several seconds
@@ -1138,8 +1117,6 @@ public class ConnectivityManagerTest {
throw new AssertionError("Timed out waiting for active network metered status to " throw new AssertionError("Timed out waiting for active network metered status to "
+ "change to " + requestedMeteredness + " ; network = " + "change to " + requestedMeteredness + " ; network = "
+ mCm.getActiveNetwork(), e); + mCm.getActiveNetwork(), e);
} finally {
mCm.unregisterNetworkCallback(networkCallback);
} }
} }
@@ -1875,8 +1852,6 @@ public class ConnectivityManagerTest {
if (supportWifi) waitForAvailable(wifiCb); if (supportWifi) waitForAvailable(wifiCb);
if (supportTelephony) waitForAvailable(telephonyCb); if (supportTelephony) waitForAvailable(telephonyCb);
} finally { } finally {
if (supportWifi) unregisterCallbackQuietly(wifiCb);
if (supportTelephony) unregisterCallbackQuietly(telephonyCb);
// Restore the previous state of airplane mode and permissions: // Restore the previous state of airplane mode and permissions:
runShellCommand("cmd connectivity airplane-mode " runShellCommand("cmd connectivity airplane-mode "
+ (isAirplaneModeEnabled ? "enable" : "disable")); + (isAirplaneModeEnabled ? "enable" : "disable"));
@@ -1886,7 +1861,7 @@ public class ConnectivityManagerTest {
private void registerCallbackAndWaitForAvailable(@NonNull final NetworkRequest request, private void registerCallbackAndWaitForAvailable(@NonNull final NetworkRequest request,
@NonNull final TestableNetworkCallback cb) { @NonNull final TestableNetworkCallback cb) {
mCm.registerNetworkCallback(request, cb); registerNetworkCallback(request, cb);
waitForAvailable(cb); waitForAvailable(cb);
} }
@@ -2004,18 +1979,15 @@ public class ConnectivityManagerTest {
foundNc.complete(nc); foundNc.complete(nc);
} }
}; };
try {
mCm.registerNetworkCallback(makeWifiNetworkRequest(), callback); registerNetworkCallback(makeWifiNetworkRequest(), callback);
// Registering a callback here guarantees onCapabilitiesChanged is called immediately // Registering a callback here guarantees onCapabilitiesChanged is called immediately
// because WiFi network should be connected. // because WiFi network should be connected.
final NetworkCapabilities nc = final NetworkCapabilities nc =
foundNc.get(NETWORK_CALLBACK_TIMEOUT_MS, TimeUnit.MILLISECONDS); foundNc.get(NETWORK_CALLBACK_TIMEOUT_MS, TimeUnit.MILLISECONDS);
// Verify if ssid is contained in the NetworkCapabilities received from callback. // Verify if ssid is contained in the NetworkCapabilities received from callback.
assertNotNull("NetworkCapabilities of the network is null", nc); assertNotNull("NetworkCapabilities of the network is null", nc);
assertEquals(hasSsid, Pattern.compile(ssid).matcher(nc.toString()).find()); assertEquals(hasSsid, Pattern.compile(ssid).matcher(nc.toString()).find());
} finally {
unregisterCallbackQuietly(callback);
}
} }
/** /**
@@ -2053,14 +2025,14 @@ public class ConnectivityManagerTest {
final TestableNetworkCallback callback = new TestableNetworkCallback(); final TestableNetworkCallback callback = new TestableNetworkCallback();
final Handler handler = new Handler(Looper.getMainLooper()); final Handler handler = new Handler(Looper.getMainLooper());
assertThrows(SecurityException.class, assertThrows(SecurityException.class,
() -> mCmShim.requestBackgroundNetwork(testRequest, callback, handler)); () -> requestBackgroundNetwork(testRequest, callback, handler));
Network testNetwork = null; Network testNetwork = null;
try { try {
// Request background test network via Shell identity which has NETWORK_SETTINGS // Request background test network via Shell identity which has NETWORK_SETTINGS
// permission granted. // permission granted.
runWithShellPermissionIdentity( runWithShellPermissionIdentity(
() -> mCmShim.requestBackgroundNetwork(testRequest, callback, handler), () -> requestBackgroundNetwork(testRequest, callback, handler),
new String[] { android.Manifest.permission.NETWORK_SETTINGS }); new String[] { android.Manifest.permission.NETWORK_SETTINGS });
// Register the test network agent which has no foreground request associated to it. // Register the test network agent which has no foreground request associated to it.
@@ -2097,7 +2069,6 @@ public class ConnectivityManagerTest {
} }
testNetworkInterface.getFileDescriptor().close(); testNetworkInterface.getFileDescriptor().close();
}, new String[] { android.Manifest.permission.MANAGE_TEST_NETWORKS }); }, new String[] { android.Manifest.permission.MANAGE_TEST_NETWORKS });
unregisterCallbackQuietly(callback);
} }
} }
@@ -2137,8 +2108,9 @@ public class ConnectivityManagerTest {
final int myUid = Process.myUid(); final int myUid = Process.myUid();
final int otherUid = UserHandle.getUid(5, Process.FIRST_APPLICATION_UID); final int otherUid = UserHandle.getUid(5, Process.FIRST_APPLICATION_UID);
final Handler handler = new Handler(Looper.getMainLooper()); final Handler handler = new Handler(Looper.getMainLooper());
mCm.registerDefaultNetworkCallback(myUidCallback, handler);
mCmShim.registerDefaultNetworkCallbackForUid(otherUid, otherUidCallback, handler); registerDefaultNetworkCallback(myUidCallback, handler);
registerDefaultNetworkCallbackForUid(otherUid, otherUidCallback, handler);
final Network defaultNetwork = mCm.getActiveNetwork(); final Network defaultNetwork = mCm.getActiveNetwork();
final List<DetailedBlockedStatusCallback> allCallbacks = final List<DetailedBlockedStatusCallback> allCallbacks =
@@ -2185,16 +2157,15 @@ public class ConnectivityManagerTest {
assertNotNull(info); assertNotNull(info);
assertEquals(DetailedState.CONNECTED, info.getDetailedState()); assertEquals(DetailedState.CONNECTED, info.getDetailedState());
final TestableNetworkCallback callback = new TestableNetworkCallback();
try { try {
mCmShim.setLegacyLockdownVpnEnabled(true); mCmShim.setLegacyLockdownVpnEnabled(true);
// setLegacyLockdownVpnEnabled is asynchronous and only takes effect when the // setLegacyLockdownVpnEnabled is asynchronous and only takes effect when the
// ConnectivityService handler thread processes it. Ensure it has taken effect by doing // ConnectivityService handler thread processes it. Ensure it has taken effect by doing
// something that blocks until the handler thread is idle. // something that blocks until the handler thread is idle.
final TestableNetworkCallback callback = new TestableNetworkCallback(); registerDefaultNetworkCallback(callback);
mCm.registerDefaultNetworkCallback(callback);
waitForAvailable(callback); waitForAvailable(callback);
mCm.unregisterNetworkCallback(callback);
// Test one of the effects of setLegacyLockdownVpnEnabled: the fact that any NetworkInfo // Test one of the effects of setLegacyLockdownVpnEnabled: the fact that any NetworkInfo
// in state CONNECTED is degraded to CONNECTING if the legacy VPN is not connected. // in state CONNECTED is degraded to CONNECTING if the legacy VPN is not connected.
@@ -2383,7 +2354,6 @@ public class ConnectivityManagerTest {
// Cleanup any prior test state from setOemNetworkPreference // Cleanup any prior test state from setOemNetworkPreference
clearOemNetworkPreference(); clearOemNetworkPreference();
unregisterTestOemNetworkPreferenceCallbacks(defaultCallback, systemDefaultCallback);
} }
} }
@@ -2427,23 +2397,15 @@ public class ConnectivityManagerTest {
// The default (non-test) network should be available as the network pref was cleared. // The default (non-test) network should be available as the network pref was cleared.
waitForAvailable(defaultCallback); waitForAvailable(defaultCallback);
unregisterTestOemNetworkPreferenceCallbacks(defaultCallback, systemDefaultCallback);
} }
} }
private void unregisterTestOemNetworkPreferenceCallbacks(
@NonNull final TestableNetworkCallback defaultCallback,
@NonNull final TestableNetworkCallback systemDefaultCallback) {
mCm.unregisterNetworkCallback(defaultCallback);
mCm.unregisterNetworkCallback(systemDefaultCallback);
}
private void registerTestOemNetworkPreferenceCallbacks( private void registerTestOemNetworkPreferenceCallbacks(
@NonNull final TestableNetworkCallback defaultCallback, @NonNull final TestableNetworkCallback defaultCallback,
@NonNull final TestableNetworkCallback systemDefaultCallback) { @NonNull final TestableNetworkCallback systemDefaultCallback) {
mCm.registerDefaultNetworkCallback(defaultCallback); registerDefaultNetworkCallback(defaultCallback);
runWithShellPermissionIdentity(() -> runWithShellPermissionIdentity(() ->
mCmShim.registerSystemDefaultNetworkCallback(systemDefaultCallback, registerSystemDefaultNetworkCallback(systemDefaultCallback,
new Handler(Looper.getMainLooper())), NETWORK_SETTINGS); new Handler(Looper.getMainLooper())), NETWORK_SETTINGS);
} }
@@ -2544,7 +2506,7 @@ public class ConnectivityManagerTest {
// Wait for partial connectivity to be detected on the network // Wait for partial connectivity to be detected on the network
final Network network = preparePartialConnectivity(); final Network network = preparePartialConnectivity();
mCm.requestNetwork(makeWifiNetworkRequest(), cb); requestNetwork(makeWifiNetworkRequest(), cb);
runAsShell(NETWORK_SETTINGS, () -> { runAsShell(NETWORK_SETTINGS, () -> {
// The always bit is verified in NetworkAgentTest // The always bit is verified in NetworkAgentTest
mCm.setAcceptPartialConnectivity(network, false /* accept */, false /* always */); mCm.setAcceptPartialConnectivity(network, false /* accept */, false /* always */);
@@ -2552,7 +2514,6 @@ public class ConnectivityManagerTest {
// Reject partial connectivity network should cause the network being torn down // Reject partial connectivity network should cause the network being torn down
assertEquals(network, cb.waitForLost()); assertEquals(network, cb.waitForLost());
} finally { } finally {
unregisterCallbackQuietly(cb);
resetValidationConfig(); resetValidationConfig();
// Wifi will not automatically reconnect to the network. ensureWifiDisconnected cannot // Wifi will not automatically reconnect to the network. ensureWifiDisconnected cannot
// apply here. Thus, turn off wifi first and restart to restore. // apply here. Thus, turn off wifi first and restart to restore.
@@ -2587,13 +2548,12 @@ public class ConnectivityManagerTest {
// guarantee that it won't become the default in the future. // guarantee that it won't become the default in the future.
assertNotEquals(wifiNetwork, mCm.getActiveNetwork()); assertNotEquals(wifiNetwork, mCm.getActiveNetwork());
mCm.registerNetworkCallback(makeWifiNetworkRequest(), wifiCb); registerNetworkCallback(makeWifiNetworkRequest(), wifiCb);
runAsShell(NETWORK_SETTINGS, () -> { runAsShell(NETWORK_SETTINGS, () -> {
mCm.setAcceptUnvalidated(wifiNetwork, false /* accept */, false /* always */); mCm.setAcceptUnvalidated(wifiNetwork, false /* accept */, false /* always */);
}); });
waitForLost(wifiCb); waitForLost(wifiCb);
} finally { } finally {
unregisterCallbackQuietly(wifiCb);
resetValidationConfig(); resetValidationConfig();
/// Wifi will not automatically reconnect to the network. ensureWifiDisconnected cannot /// Wifi will not automatically reconnect to the network. ensureWifiDisconnected cannot
// apply here. Thus, turn off wifi first and restart to restore. // apply here. Thus, turn off wifi first and restart to restore.
@@ -2623,8 +2583,8 @@ public class ConnectivityManagerTest {
final Network cellNetwork = mCtsNetUtils.connectToCell(); final Network cellNetwork = mCtsNetUtils.connectToCell();
final Network wifiNetwork = prepareValidatedNetwork(); final Network wifiNetwork = prepareValidatedNetwork();
mCm.registerDefaultNetworkCallback(defaultCb); registerDefaultNetworkCallback(defaultCb);
mCm.registerNetworkCallback(makeWifiNetworkRequest(), wifiCb); registerNetworkCallback(makeWifiNetworkRequest(), wifiCb);
try { try {
// Verify wifi is the default network. // Verify wifi is the default network.
@@ -2658,8 +2618,6 @@ public class ConnectivityManagerTest {
wifiCb.assertNoCallbackThat(NO_CALLBACK_TIMEOUT_MS, wifiCb.assertNoCallbackThat(NO_CALLBACK_TIMEOUT_MS,
c -> !(c instanceof CallbackEntry.LinkPropertiesChanged)); c -> !(c instanceof CallbackEntry.LinkPropertiesChanged));
} finally { } finally {
unregisterCallbackQuietly(wifiCb);
unregisterCallbackQuietly(defaultCb);
resetAvoidBadWifi(previousAvoidBadWifi); resetAvoidBadWifi(previousAvoidBadWifi);
resetValidationConfig(); resetValidationConfig();
// Reconnect wifi to reset the wifi status // Reconnect wifi to reset the wifi status
@@ -2697,12 +2655,8 @@ public class ConnectivityManagerTest {
} }
}; };
try { registerNetworkCallback(new NetworkRequest.Builder().build(), cb);
mCm.registerNetworkCallback(new NetworkRequest.Builder().build(), cb); return future.get(timeout, TimeUnit.MILLISECONDS);
return future.get(timeout, TimeUnit.MILLISECONDS);
} finally {
unregisterCallbackQuietly(cb);
}
} }
private void resetValidationConfig() { private void resetValidationConfig() {
@@ -2788,14 +2742,6 @@ public class ConnectivityManagerTest {
System.currentTimeMillis() + WIFI_CONNECT_TIMEOUT_MS); System.currentTimeMillis() + WIFI_CONNECT_TIMEOUT_MS);
} }
private void unregisterCallbackQuietly(NetworkCallback cb) {
try {
mCm.unregisterNetworkCallback(cb);
} catch (IllegalArgumentException e) {
Log.i(TAG, "Try to unregister a not registered NetworkCallback!");
}
}
@AppModeFull(reason = "Cannot get WifiManager in instant app mode") @AppModeFull(reason = "Cannot get WifiManager in instant app mode")
@Test @Test
public void testMobileDataPreferredUids() throws Exception { public void testMobileDataPreferredUids() throws Exception {
@@ -2820,9 +2766,9 @@ public class ConnectivityManagerTest {
final TestableNetworkCallback defaultTrackingCb = new TestableNetworkCallback(); final TestableNetworkCallback defaultTrackingCb = new TestableNetworkCallback();
final TestableNetworkCallback systemDefaultCb = new TestableNetworkCallback(); final TestableNetworkCallback systemDefaultCb = new TestableNetworkCallback();
final Handler h = new Handler(Looper.getMainLooper()); final Handler h = new Handler(Looper.getMainLooper());
runWithShellPermissionIdentity(() -> mCm.registerSystemDefaultNetworkCallback( runWithShellPermissionIdentity(() -> registerSystemDefaultNetworkCallback(
systemDefaultCb, h), NETWORK_SETTINGS); systemDefaultCb, h), NETWORK_SETTINGS);
mCm.registerDefaultNetworkCallback(defaultTrackingCb); registerDefaultNetworkCallback(defaultTrackingCb);
try { try {
// CtsNetTestCases uid is not listed in MOBILE_DATA_PREFERRED_UIDS setting, so the // CtsNetTestCases uid is not listed in MOBILE_DATA_PREFERRED_UIDS setting, so the
@@ -2858,9 +2804,6 @@ public class ConnectivityManagerTest {
// Active network for CtsNetTestCases uid should change back to wifi. // Active network for CtsNetTestCases uid should change back to wifi.
assertEquals(wifiNetwork, mCm.getActiveNetwork()); assertEquals(wifiNetwork, mCm.getActiveNetwork());
} finally { } finally {
unregisterCallbackQuietly(systemDefaultCb);
unregisterCallbackQuietly(defaultTrackingCb);
// Restore setting. // Restore setting.
ConnectivitySettingsManager.setMobileDataPreferredUids( ConnectivitySettingsManager.setMobileDataPreferredUids(
mContext, mobileDataPreferredUids); mContext, mobileDataPreferredUids);
@@ -2911,7 +2854,7 @@ public class ConnectivityManagerTest {
final Handler h = new Handler(Looper.getMainLooper()); final Handler h = new Handler(Looper.getMainLooper());
final TestableNetworkCallback testNetworkCb = new TestableNetworkCallback(); final TestableNetworkCallback testNetworkCb = new TestableNetworkCallback();
mCm.registerBestMatchingNetworkCallback(new NetworkRequest.Builder().clearCapabilities() registerBestMatchingNetworkCallback(new NetworkRequest.Builder().clearCapabilities()
.addTransportType(NetworkCapabilities.TRANSPORT_TEST).build(), testNetworkCb, h); .addTransportType(NetworkCapabilities.TRANSPORT_TEST).build(), testNetworkCb, h);
// Create test network agent with restricted network. // Create test network agent with restricted network.
@@ -2961,7 +2904,6 @@ public class ConnectivityManagerTest {
// TODD: Have a significant signal to know the uids has been send to netd. // TODD: Have a significant signal to know the uids has been send to netd.
assertBindSocketToNetworkSuccess(network); assertBindSocketToNetworkSuccess(network);
} finally { } finally {
unregisterCallbackQuietly(testNetworkCb);
agent.unregister(); agent.unregister();
// Restore setting. // Restore setting.
@@ -2970,4 +2912,58 @@ public class ConnectivityManagerTest {
mContext, originalUidsAllowedOnRestrictedNetworks), NETWORK_SETTINGS); mContext, originalUidsAllowedOnRestrictedNetworks), NETWORK_SETTINGS);
} }
} }
private void unregisterRegisteredCallbacks() {
for (NetworkCallback callback: mRegisteredCallbacks) {
mCm.unregisterNetworkCallback(callback);
}
}
private void registerDefaultNetworkCallback(NetworkCallback callback) {
mCm.registerDefaultNetworkCallback(callback);
mRegisteredCallbacks.add(callback);
}
private void registerDefaultNetworkCallback(NetworkCallback callback, Handler handler) {
mCm.registerDefaultNetworkCallback(callback, handler);
mRegisteredCallbacks.add(callback);
}
private void registerNetworkCallback(NetworkRequest request, NetworkCallback callback) {
mCm.registerNetworkCallback(request, callback);
mRegisteredCallbacks.add(callback);
}
private void registerSystemDefaultNetworkCallback(NetworkCallback callback, Handler handler) {
mCmShim.registerSystemDefaultNetworkCallback(callback, handler);
mRegisteredCallbacks.add(callback);
}
private void registerDefaultNetworkCallbackForUid(int uid, NetworkCallback callback,
Handler handler) throws Exception {
mCmShim.registerDefaultNetworkCallbackForUid(uid, callback, handler);
mRegisteredCallbacks.add(callback);
}
private void requestNetwork(NetworkRequest request, NetworkCallback callback) {
mCm.requestNetwork(request, callback);
mRegisteredCallbacks.add(callback);
}
private void requestNetwork(NetworkRequest request, NetworkCallback callback, int timeoutSec) {
mCm.requestNetwork(request, callback, timeoutSec);
mRegisteredCallbacks.add(callback);
}
private void registerBestMatchingNetworkCallback(NetworkRequest request,
NetworkCallback callback, Handler handler) {
mCm.registerBestMatchingNetworkCallback(request, callback, handler);
mRegisteredCallbacks.add(callback);
}
private void requestBackgroundNetwork(NetworkRequest request, NetworkCallback callback,
Handler handler) throws Exception {
mCmShim.requestBackgroundNetwork(request, callback, handler);
mRegisteredCallbacks.add(callback);
}
} }