Merge changes I69128db9,I13db22f8
* changes:
Implement onServiceConflict
Add replying to queries
diff --git a/Cronet/tests/cts/src/android/net/http/cts/CronetUrlRequestTest.java b/Cronet/tests/cts/src/android/net/http/cts/CronetUrlRequestTest.java
index 2898f54..09f880b 100644
--- a/Cronet/tests/cts/src/android/net/http/cts/CronetUrlRequestTest.java
+++ b/Cronet/tests/cts/src/android/net/http/cts/CronetUrlRequestTest.java
@@ -23,6 +23,7 @@
import android.content.Context;
import android.net.ConnectivityManager;
import android.net.http.cts.util.CronetCtsTestServer;
+import android.net.http.cts.util.TestStatusListener;
import android.net.http.cts.util.TestUrlRequestCallback;
import android.net.http.cts.util.TestUrlRequestCallback.ResponseStep;
@@ -32,6 +33,7 @@
import org.chromium.net.CronetEngine;
import org.chromium.net.UrlRequest;
+import org.chromium.net.UrlRequest.Status;
import org.chromium.net.UrlResponseInfo;
import org.junit.After;
import org.junit.Before;
@@ -43,6 +45,7 @@
private static final String TAG = CronetUrlRequestTest.class.getSimpleName();
@NonNull private CronetEngine mCronetEngine;
+ @NonNull private TestUrlRequestCallback mCallback;
@NonNull private ConnectivityManager mCm;
@NonNull private CronetCtsTestServer mTestServer;
@@ -56,6 +59,7 @@
// .enableBrotli(true)
.enableQuic(true);
mCronetEngine = builder.build();
+ mCallback = new TestUrlRequestCallback();
mTestServer = new CronetCtsTestServer(context);
}
@@ -73,21 +77,33 @@
assertNotNull("This test requires a working Internet connection", mCm.getActiveNetwork());
}
+ private UrlRequest buildUrlRequest(String url) {
+ return mCronetEngine.newUrlRequestBuilder(url, mCallback, mCallback.getExecutor()).build();
+ }
+
@Test
public void testUrlRequestGet_CompletesSuccessfully() throws Exception {
assertHasTestableNetworks();
String url = mTestServer.getSuccessUrl();
- TestUrlRequestCallback callback = new TestUrlRequestCallback();
- UrlRequest.Builder builder =
- mCronetEngine.newUrlRequestBuilder(url, callback, callback.getExecutor());
- builder.build().start();
+ UrlRequest request = buildUrlRequest(url);
+ request.start();
- callback.expectCallback(ResponseStep.ON_SUCCEEDED);
+ mCallback.expectCallback(ResponseStep.ON_SUCCEEDED);
- UrlResponseInfo info = callback.mResponseInfo;
+ UrlResponseInfo info = mCallback.mResponseInfo;
assertEquals(
"Unexpected http status code from " + url + ".", 200, info.getHttpStatusCode());
assertGreaterThan(
"Received byte from " + url + " is 0.", (int) info.getReceivedByteCount(), 0);
}
+
+ @Test
+ public void testUrlRequestStatus_InvalidBeforeRequestStarts() throws Exception {
+ UrlRequest request = buildUrlRequest(mTestServer.getSuccessUrl());
+ // Calling before request is started should give Status.INVALID,
+ // since the native adapter is not created.
+ TestStatusListener statusListener = new TestStatusListener();
+ request.getStatus(statusListener);
+ statusListener.expectStatus(Status.INVALID);
+ }
}
diff --git a/Cronet/tests/cts/src/android/net/http/cts/util/TestStatusListener.kt b/Cronet/tests/cts/src/android/net/http/cts/util/TestStatusListener.kt
new file mode 100644
index 0000000..4d26ec0
--- /dev/null
+++ b/Cronet/tests/cts/src/android/net/http/cts/util/TestStatusListener.kt
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2022 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.http.cts.util
+
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.TimeUnit
+import org.chromium.net.UrlRequest.StatusListener
+import org.junit.Assert.assertSame
+
+private const val TIMEOUT_MS = 12000L
+
+/** Test status listener for requests */
+class TestStatusListener : StatusListener() {
+ private val statusFuture = CompletableFuture<Int>()
+
+ override fun onStatus(status: Int) {
+ statusFuture.complete(status)
+ }
+
+ /** Fails if the expected status is not the returned status */
+ fun expectStatus(expected: Int) {
+ assertSame(expected, statusFuture.get(TIMEOUT_MS, TimeUnit.MILLISECONDS))
+ }
+}
diff --git a/Tethering/apex/Android.bp b/Tethering/apex/Android.bp
index 565675f..b26911c 100644
--- a/Tethering/apex/Android.bp
+++ b/Tethering/apex/Android.bp
@@ -59,11 +59,31 @@
// as cronet_apex_defaults may have different values
// depending on the branch
+apex_defaults {
+ name: "CronetInTetheringApexDefaults",
+ defaults: [cronet_in_tethering_apex_defaults],
+}
+
+apex_defaults {
+ name: "CronetInTetheringApexDefaultsEnabled",
+ jni_libs: ["cronet_aml_components_cronet_android_cronet"],
+ arch: {
+ riscv64: {
+ // TODO: remove this when there is a riscv64 libcronet
+ exclude_jni_libs: ["cronet_aml_components_cronet_android_cronet"],
+ },
+ },
+}
+
+apex_defaults {
+ name: "CronetInTetheringApexDefaultsDisabled",
+}
+
apex {
name: "com.android.tethering",
defaults: [
"ConnectivityApexDefaults",
- "CronetApexDefaults",
+ "CronetInTetheringApexDefaults",
"r-launched-apex-module",
],
compile_multilib: "both",
@@ -192,6 +212,7 @@
"android.app.usage",
"android.nearby",
"android.net",
+ "android.net.http",
"android.net.netstats",
"android.net.util",
],
@@ -206,6 +227,8 @@
"android.nearby.aidl",
"android.net.apf",
"android.net.connectivity",
+ "android.net.http.apihelpers",
+ "android.net.http.internal",
"android.net.netstats.provider",
"android.net.nsd",
"android.net.wear",
diff --git a/Tethering/common/TetheringLib/Android.bp b/Tethering/common/TetheringLib/Android.bp
index 6df522c..cbdf0c0 100644
--- a/Tethering/common/TetheringLib/Android.bp
+++ b/Tethering/common/TetheringLib/Android.bp
@@ -17,8 +17,6 @@
default_applicable_licenses: ["Android-Apache-2.0"],
}
-// TODO: This is currently not used, but is being merged early, so Cronet can be disabled in
-// tm-mainline-prod.
// Both cronet_java_defaults and cronet_java_prejarjar_defaults can be used to
// specify a java_defaults target that either enables or disables Cronet. This
// is used to disable Cronet on tm-mainline-prod.
@@ -29,9 +27,20 @@
// as cronet_defaults may have different values
// depending on the branch
+// cronet_java_defaults_enabled_srcs is used to specify the srcs of CronetJavaDefaultsEnabled
+// This is required until the external/cronet is auto-merged to tm-mainline-prod and
+// :cronet_aml_api_sources is available
+cronet_java_defaults_enabled_srcs = [":cronet_aml_api_sources"]
+// This is a placeholder comment to avoid merge conflicts
+// as cronet_defaults may have different values
+// depending on the branch
+
java_sdk_library {
name: "framework-tethering",
- defaults: ["framework-tethering-defaults"],
+ defaults: [
+ "CronetJavaDefaults",
+ "framework-tethering-defaults",
+ ],
impl_library_visibility: [
"//packages/modules/Connectivity/Tethering:__subpackages__",
"//packages/modules/Connectivity/framework",
@@ -64,12 +73,61 @@
hostdex: true, // for hiddenapi check
permitted_packages: ["android.net"],
- lint: { strict_updatability_linting: true },
+}
+
+java_defaults {
+ name: "CronetJavaDefaults",
+ defaults: [cronet_java_defaults],
+}
+
+java_defaults {
+ name: "CronetJavaDefaultsEnabled",
+ srcs: cronet_java_defaults_enabled_srcs,
+ libs: [
+ "androidx.annotation_annotation",
+ ],
+ impl_only_static_libs: [
+ "cronet_aml_java",
+ ],
+ // STOPSHIP(b/265674359): fix all Cronet lint warnings and re-enable lint
+ // directly in framework-tethering
+ lint: {
+ enabled: false,
+ },
+ api_lint: {
+ enabled: false,
+ },
+ api_dir: "cronet_enabled/api",
+}
+
+java_defaults {
+ name: "CronetJavaDefaultsDisabled",
+ lint: { strict_updatability_linting: true },
+}
+
+java_defaults {
+ name: "CronetJavaPrejarjarDefaults",
+ defaults: [cronet_java_prejarjar_defaults],
+}
+
+java_defaults {
+ name: "CronetJavaPrejarjarDefaultsDisabled",
+}
+
+java_defaults {
+ name: "CronetJavaPrejarjarDefaultsEnabled",
+ static_libs: [
+ "cronet_aml_api_java",
+ "cronet_aml_java"
+ ],
}
java_library {
name: "framework-tethering-pre-jarjar",
- defaults: ["framework-tethering-defaults"],
+ defaults: [
+ "framework-tethering-defaults",
+ "CronetJavaPrejarjarDefaults",
+ ],
}
java_genrule {
diff --git a/Tethering/common/TetheringLib/cronet_enabled/api/current.txt b/Tethering/common/TetheringLib/cronet_enabled/api/current.txt
new file mode 100644
index 0000000..c0157b7
--- /dev/null
+++ b/Tethering/common/TetheringLib/cronet_enabled/api/current.txt
@@ -0,0 +1,194 @@
+// Signature format: 2.0
+package android.net.http {
+
+ public abstract class CallbackException extends android.net.http.HttpException {
+ ctor protected CallbackException(String, Throwable);
+ }
+
+ public class ConnectionMigrationOptions {
+ method @Nullable public Boolean getEnableDefaultNetworkMigration();
+ method @Nullable public Boolean getEnablePathDegradationMigration();
+ }
+
+ public static class ConnectionMigrationOptions.Builder {
+ ctor public ConnectionMigrationOptions.Builder();
+ method public android.net.http.ConnectionMigrationOptions build();
+ method public android.net.http.ConnectionMigrationOptions.Builder setEnableDefaultNetworkMigration(boolean);
+ method public android.net.http.ConnectionMigrationOptions.Builder setEnablePathDegradationMigration(boolean);
+ }
+
+ public final class DnsOptions {
+ method @Nullable public Boolean getPersistHostCache();
+ method @Nullable public java.time.Duration getPersistHostCachePeriod();
+ }
+
+ public static final class DnsOptions.Builder {
+ ctor public DnsOptions.Builder();
+ method public android.net.http.DnsOptions build();
+ method public android.net.http.DnsOptions.Builder setPersistHostCache(boolean);
+ method public android.net.http.DnsOptions.Builder setPersistHostCachePeriod(java.time.Duration);
+ }
+
+ public abstract class HttpEngine {
+ method public abstract java.net.URLStreamHandlerFactory createURLStreamHandlerFactory();
+ method public abstract String getVersionString();
+ method public abstract android.net.http.UrlRequest.Builder newUrlRequestBuilder(String, android.net.http.UrlRequest.Callback, java.util.concurrent.Executor);
+ method public abstract java.net.URLConnection openConnection(java.net.URL) throws java.io.IOException;
+ method public abstract void shutdown();
+ }
+
+ public static class HttpEngine.Builder {
+ ctor public HttpEngine.Builder(android.content.Context);
+ method public android.net.http.HttpEngine.Builder addPublicKeyPins(String, java.util.Set<byte[]>, boolean, java.time.Instant);
+ method public android.net.http.HttpEngine.Builder addQuicHint(String, int, int);
+ method public android.net.http.HttpEngine build();
+ method public String getDefaultUserAgent();
+ method public android.net.http.HttpEngine.Builder setConnectionMigrationOptions(android.net.http.ConnectionMigrationOptions);
+ method public android.net.http.HttpEngine.Builder setDnsOptions(android.net.http.DnsOptions);
+ method public android.net.http.HttpEngine.Builder setEnableBrotli(boolean);
+ method public android.net.http.HttpEngine.Builder setEnableHttp2(boolean);
+ method public android.net.http.HttpEngine.Builder setEnableHttpCache(int, long);
+ method public android.net.http.HttpEngine.Builder setEnablePublicKeyPinningBypassForLocalTrustAnchors(boolean);
+ method public android.net.http.HttpEngine.Builder setEnableQuic(boolean);
+ method public android.net.http.HttpEngine.Builder setQuicOptions(android.net.http.QuicOptions);
+ method public android.net.http.HttpEngine.Builder setStoragePath(String);
+ method public android.net.http.HttpEngine.Builder setUserAgent(String);
+ field public static final int HTTP_CACHE_DISABLED = 0; // 0x0
+ field public static final int HTTP_CACHE_DISK = 3; // 0x3
+ field public static final int HTTP_CACHE_DISK_NO_HTTP = 2; // 0x2
+ field public static final int HTTP_CACHE_IN_MEMORY = 1; // 0x1
+ }
+
+ public class HttpException extends java.io.IOException {
+ ctor public HttpException(String, Throwable);
+ }
+
+ public final class InlineExecutionProhibitedException extends java.util.concurrent.RejectedExecutionException {
+ ctor public InlineExecutionProhibitedException();
+ }
+
+ public abstract class NetworkException extends android.net.http.HttpException {
+ ctor public NetworkException(String, Throwable);
+ method public abstract int getErrorCode();
+ method public abstract boolean isImmediatelyRetryable();
+ field public static final int ERROR_ADDRESS_UNREACHABLE = 9; // 0x9
+ field public static final int ERROR_CONNECTION_CLOSED = 5; // 0x5
+ field public static final int ERROR_CONNECTION_REFUSED = 7; // 0x7
+ field public static final int ERROR_CONNECTION_RESET = 8; // 0x8
+ field public static final int ERROR_CONNECTION_TIMED_OUT = 6; // 0x6
+ field public static final int ERROR_HOSTNAME_NOT_RESOLVED = 1; // 0x1
+ field public static final int ERROR_INTERNET_DISCONNECTED = 2; // 0x2
+ field public static final int ERROR_NETWORK_CHANGED = 3; // 0x3
+ field public static final int ERROR_OTHER = 11; // 0xb
+ field public static final int ERROR_QUIC_PROTOCOL_FAILED = 10; // 0xa
+ field public static final int ERROR_TIMED_OUT = 4; // 0x4
+ }
+
+ public abstract class QuicException extends android.net.http.NetworkException {
+ ctor protected QuicException(String, Throwable);
+ }
+
+ public class QuicOptions {
+ method @Nullable public String getHandshakeUserAgent();
+ method @Nullable public Integer getInMemoryServerConfigsCacheSize();
+ method public java.util.Set<java.lang.String> getQuicHostAllowlist();
+ }
+
+ public static class QuicOptions.Builder {
+ ctor public QuicOptions.Builder();
+ method public android.net.http.QuicOptions.Builder addAllowedQuicHost(String);
+ method public android.net.http.QuicOptions build();
+ method public android.net.http.QuicOptions.Builder setHandshakeUserAgent(String);
+ method public android.net.http.QuicOptions.Builder setInMemoryServerConfigsCacheSize(int);
+ }
+
+ public abstract class UploadDataProvider implements java.io.Closeable {
+ ctor public UploadDataProvider();
+ method public void close() throws java.io.IOException;
+ method public abstract long getLength() throws java.io.IOException;
+ method public abstract void read(android.net.http.UploadDataSink, java.nio.ByteBuffer) throws java.io.IOException;
+ method public abstract void rewind(android.net.http.UploadDataSink) throws java.io.IOException;
+ }
+
+ public abstract class UploadDataSink {
+ ctor public UploadDataSink();
+ method public abstract void onReadError(Exception);
+ method public abstract void onReadSucceeded(boolean);
+ method public abstract void onRewindError(Exception);
+ method public abstract void onRewindSucceeded();
+ }
+
+ public abstract class UrlRequest {
+ method public abstract void cancel();
+ method public abstract void followRedirect();
+ method public abstract void getStatus(android.net.http.UrlRequest.StatusListener);
+ method public abstract boolean isDone();
+ method public abstract void read(java.nio.ByteBuffer);
+ method public abstract void start();
+ }
+
+ public abstract static class UrlRequest.Builder {
+ method public abstract android.net.http.UrlRequest.Builder addHeader(String, String);
+ method public abstract android.net.http.UrlRequest.Builder allowDirectExecutor();
+ method public abstract android.net.http.UrlRequest build();
+ method public abstract android.net.http.UrlRequest.Builder disableCache();
+ method public abstract android.net.http.UrlRequest.Builder setHttpMethod(String);
+ method public abstract android.net.http.UrlRequest.Builder setPriority(int);
+ method public abstract android.net.http.UrlRequest.Builder setUploadDataProvider(android.net.http.UploadDataProvider, java.util.concurrent.Executor);
+ field public static final int REQUEST_PRIORITY_HIGHEST = 4; // 0x4
+ field public static final int REQUEST_PRIORITY_IDLE = 0; // 0x0
+ field public static final int REQUEST_PRIORITY_LOW = 2; // 0x2
+ field public static final int REQUEST_PRIORITY_LOWEST = 1; // 0x1
+ field public static final int REQUEST_PRIORITY_MEDIUM = 3; // 0x3
+ }
+
+ public abstract static class UrlRequest.Callback {
+ ctor public UrlRequest.Callback();
+ method public void onCanceled(android.net.http.UrlRequest, android.net.http.UrlResponseInfo);
+ method public abstract void onFailed(android.net.http.UrlRequest, android.net.http.UrlResponseInfo, android.net.http.HttpException);
+ method public abstract void onReadCompleted(android.net.http.UrlRequest, android.net.http.UrlResponseInfo, java.nio.ByteBuffer) throws java.lang.Exception;
+ method public abstract void onRedirectReceived(android.net.http.UrlRequest, android.net.http.UrlResponseInfo, String) throws java.lang.Exception;
+ method public abstract void onResponseStarted(android.net.http.UrlRequest, android.net.http.UrlResponseInfo) throws java.lang.Exception;
+ method public abstract void onSucceeded(android.net.http.UrlRequest, android.net.http.UrlResponseInfo);
+ }
+
+ public static class UrlRequest.Status {
+ field public static final int CONNECTING = 10; // 0xa
+ field public static final int DOWNLOADING_PAC_FILE = 5; // 0x5
+ field public static final int ESTABLISHING_PROXY_TUNNEL = 8; // 0x8
+ field public static final int IDLE = 0; // 0x0
+ field public static final int INVALID = -1; // 0xffffffff
+ field public static final int READING_RESPONSE = 14; // 0xe
+ field public static final int RESOLVING_HOST = 9; // 0x9
+ field public static final int RESOLVING_HOST_IN_PAC_FILE = 7; // 0x7
+ field public static final int RESOLVING_PROXY_FOR_URL = 6; // 0x6
+ field public static final int SENDING_REQUEST = 12; // 0xc
+ field public static final int SSL_HANDSHAKE = 11; // 0xb
+ field public static final int WAITING_FOR_AVAILABLE_SOCKET = 2; // 0x2
+ field public static final int WAITING_FOR_CACHE = 4; // 0x4
+ field public static final int WAITING_FOR_DELEGATE = 3; // 0x3
+ field public static final int WAITING_FOR_RESPONSE = 13; // 0xd
+ field public static final int WAITING_FOR_STALLED_SOCKET_POOL = 1; // 0x1
+ }
+
+ public abstract static class UrlRequest.StatusListener {
+ ctor public UrlRequest.StatusListener();
+ method public abstract void onStatus(int);
+ }
+
+ public abstract class UrlResponseInfo {
+ ctor public UrlResponseInfo();
+ method public abstract java.util.Map<java.lang.String,java.util.List<java.lang.String>> getAllHeaders();
+ method public abstract java.util.List<java.util.Map.Entry<java.lang.String,java.lang.String>> getAllHeadersAsList();
+ method public abstract int getHttpStatusCode();
+ method public abstract String getHttpStatusText();
+ method public abstract String getNegotiatedProtocol();
+ method public abstract String getProxyServer();
+ method public abstract long getReceivedByteCount();
+ method public abstract String getUrl();
+ method public abstract java.util.List<java.lang.String> getUrlChain();
+ method public abstract boolean wasCached();
+ }
+
+}
+
diff --git a/Tethering/common/TetheringLib/cronet_enabled/api/module-lib-current.txt b/Tethering/common/TetheringLib/cronet_enabled/api/module-lib-current.txt
new file mode 100644
index 0000000..460c216
--- /dev/null
+++ b/Tethering/common/TetheringLib/cronet_enabled/api/module-lib-current.txt
@@ -0,0 +1,50 @@
+// Signature format: 2.0
+package android.net {
+
+ public final class TetheringConstants {
+ field public static final String EXTRA_ADD_TETHER_TYPE = "extraAddTetherType";
+ field public static final String EXTRA_PROVISION_CALLBACK = "extraProvisionCallback";
+ field public static final String EXTRA_REM_TETHER_TYPE = "extraRemTetherType";
+ field public static final String EXTRA_RUN_PROVISION = "extraRunProvision";
+ field public static final String EXTRA_SET_ALARM = "extraSetAlarm";
+ }
+
+ public class TetheringManager {
+ ctor public TetheringManager(@NonNull android.content.Context, @NonNull java.util.function.Supplier<android.os.IBinder>);
+ method public int getLastTetherError(@NonNull String);
+ method @NonNull public String[] getTetherableBluetoothRegexs();
+ method @NonNull public String[] getTetherableIfaces();
+ method @NonNull public String[] getTetherableUsbRegexs();
+ method @NonNull public String[] getTetherableWifiRegexs();
+ method @NonNull public String[] getTetheredIfaces();
+ method @NonNull public String[] getTetheringErroredIfaces();
+ method public boolean isTetheringSupported();
+ method public boolean isTetheringSupported(@NonNull String);
+ method public void requestLatestTetheringEntitlementResult(int, @NonNull android.os.ResultReceiver, boolean);
+ method @Deprecated public int setUsbTethering(boolean);
+ method @RequiresPermission(anyOf={android.Manifest.permission.TETHER_PRIVILEGED, android.Manifest.permission.WRITE_SETTINGS}) public void startTethering(int, @NonNull java.util.concurrent.Executor, @NonNull android.net.TetheringManager.StartTetheringCallback);
+ method @Deprecated public int tether(@NonNull String);
+ method @Deprecated public int untether(@NonNull String);
+ }
+
+ public static interface TetheringManager.TetheredInterfaceCallback {
+ method public void onAvailable(@NonNull String);
+ method public void onUnavailable();
+ }
+
+ public static interface TetheringManager.TetheredInterfaceRequest {
+ method public void release();
+ }
+
+ public static interface TetheringManager.TetheringEventCallback {
+ method @Deprecated public default void onTetherableInterfaceRegexpsChanged(@NonNull android.net.TetheringManager.TetheringInterfaceRegexps);
+ }
+
+ @Deprecated public static class TetheringManager.TetheringInterfaceRegexps {
+ method @Deprecated @NonNull public java.util.List<java.lang.String> getTetherableBluetoothRegexs();
+ method @Deprecated @NonNull public java.util.List<java.lang.String> getTetherableUsbRegexs();
+ method @Deprecated @NonNull public java.util.List<java.lang.String> getTetherableWifiRegexs();
+ }
+
+}
+
diff --git a/Tethering/common/TetheringLib/cronet_enabled/api/module-lib-removed.txt b/Tethering/common/TetheringLib/cronet_enabled/api/module-lib-removed.txt
new file mode 100644
index 0000000..d802177
--- /dev/null
+++ b/Tethering/common/TetheringLib/cronet_enabled/api/module-lib-removed.txt
@@ -0,0 +1 @@
+// Signature format: 2.0
diff --git a/Tethering/common/TetheringLib/cronet_enabled/api/removed.txt b/Tethering/common/TetheringLib/cronet_enabled/api/removed.txt
new file mode 100644
index 0000000..d802177
--- /dev/null
+++ b/Tethering/common/TetheringLib/cronet_enabled/api/removed.txt
@@ -0,0 +1 @@
+// Signature format: 2.0
diff --git a/Tethering/common/TetheringLib/cronet_enabled/api/system-current.txt b/Tethering/common/TetheringLib/cronet_enabled/api/system-current.txt
new file mode 100644
index 0000000..844ff64
--- /dev/null
+++ b/Tethering/common/TetheringLib/cronet_enabled/api/system-current.txt
@@ -0,0 +1,117 @@
+// Signature format: 2.0
+package android.net {
+
+ public final class TetheredClient implements android.os.Parcelable {
+ ctor public TetheredClient(@NonNull android.net.MacAddress, @NonNull java.util.Collection<android.net.TetheredClient.AddressInfo>, int);
+ method public int describeContents();
+ method @NonNull public java.util.List<android.net.TetheredClient.AddressInfo> getAddresses();
+ method @NonNull public android.net.MacAddress getMacAddress();
+ method public int getTetheringType();
+ method public void writeToParcel(@NonNull android.os.Parcel, int);
+ field @NonNull public static final android.os.Parcelable.Creator<android.net.TetheredClient> CREATOR;
+ }
+
+ public static final class TetheredClient.AddressInfo implements android.os.Parcelable {
+ method public int describeContents();
+ method @NonNull public android.net.LinkAddress getAddress();
+ method @Nullable public String getHostname();
+ method public void writeToParcel(@NonNull android.os.Parcel, int);
+ field @NonNull public static final android.os.Parcelable.Creator<android.net.TetheredClient.AddressInfo> CREATOR;
+ }
+
+ public final class TetheringInterface implements android.os.Parcelable {
+ ctor public TetheringInterface(int, @NonNull String);
+ method public int describeContents();
+ method @NonNull public String getInterface();
+ method public int getType();
+ method public void writeToParcel(@NonNull android.os.Parcel, int);
+ field @NonNull public static final android.os.Parcelable.Creator<android.net.TetheringInterface> CREATOR;
+ }
+
+ public class TetheringManager {
+ method @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) public void registerTetheringEventCallback(@NonNull java.util.concurrent.Executor, @NonNull android.net.TetheringManager.TetheringEventCallback);
+ method @RequiresPermission(anyOf={android.Manifest.permission.TETHER_PRIVILEGED, android.Manifest.permission.WRITE_SETTINGS}) public void requestLatestTetheringEntitlementResult(int, boolean, @NonNull java.util.concurrent.Executor, @NonNull android.net.TetheringManager.OnTetheringEntitlementResultListener);
+ method @RequiresPermission(anyOf={android.Manifest.permission.TETHER_PRIVILEGED, android.Manifest.permission.WRITE_SETTINGS}) public void startTethering(@NonNull android.net.TetheringManager.TetheringRequest, @NonNull java.util.concurrent.Executor, @NonNull android.net.TetheringManager.StartTetheringCallback);
+ method @RequiresPermission(anyOf={android.Manifest.permission.TETHER_PRIVILEGED, android.Manifest.permission.WRITE_SETTINGS}) public void stopAllTethering();
+ method @RequiresPermission(anyOf={android.Manifest.permission.TETHER_PRIVILEGED, android.Manifest.permission.WRITE_SETTINGS}) public void stopTethering(int);
+ method @RequiresPermission(anyOf={android.Manifest.permission.TETHER_PRIVILEGED, android.Manifest.permission.ACCESS_NETWORK_STATE}) public void unregisterTetheringEventCallback(@NonNull android.net.TetheringManager.TetheringEventCallback);
+ field @Deprecated public static final String ACTION_TETHER_STATE_CHANGED = "android.net.conn.TETHER_STATE_CHANGED";
+ field public static final int CONNECTIVITY_SCOPE_GLOBAL = 1; // 0x1
+ field public static final int CONNECTIVITY_SCOPE_LOCAL = 2; // 0x2
+ field public static final String EXTRA_ACTIVE_LOCAL_ONLY = "android.net.extra.ACTIVE_LOCAL_ONLY";
+ field public static final String EXTRA_ACTIVE_TETHER = "tetherArray";
+ field public static final String EXTRA_AVAILABLE_TETHER = "availableArray";
+ field public static final String EXTRA_ERRORED_TETHER = "erroredArray";
+ field public static final int TETHERING_BLUETOOTH = 2; // 0x2
+ field public static final int TETHERING_ETHERNET = 5; // 0x5
+ field public static final int TETHERING_INVALID = -1; // 0xffffffff
+ field public static final int TETHERING_NCM = 4; // 0x4
+ field public static final int TETHERING_USB = 1; // 0x1
+ field public static final int TETHERING_WIFI = 0; // 0x0
+ field public static final int TETHERING_WIFI_P2P = 3; // 0x3
+ field public static final int TETHER_ERROR_DHCPSERVER_ERROR = 12; // 0xc
+ field public static final int TETHER_ERROR_DISABLE_FORWARDING_ERROR = 9; // 0x9
+ field public static final int TETHER_ERROR_ENABLE_FORWARDING_ERROR = 8; // 0x8
+ field public static final int TETHER_ERROR_ENTITLEMENT_UNKNOWN = 13; // 0xd
+ field public static final int TETHER_ERROR_IFACE_CFG_ERROR = 10; // 0xa
+ field public static final int TETHER_ERROR_INTERNAL_ERROR = 5; // 0x5
+ field public static final int TETHER_ERROR_NO_ACCESS_TETHERING_PERMISSION = 15; // 0xf
+ field public static final int TETHER_ERROR_NO_CHANGE_TETHERING_PERMISSION = 14; // 0xe
+ field public static final int TETHER_ERROR_NO_ERROR = 0; // 0x0
+ field public static final int TETHER_ERROR_PROVISIONING_FAILED = 11; // 0xb
+ field public static final int TETHER_ERROR_SERVICE_UNAVAIL = 2; // 0x2
+ field public static final int TETHER_ERROR_TETHER_IFACE_ERROR = 6; // 0x6
+ field public static final int TETHER_ERROR_UNAVAIL_IFACE = 4; // 0x4
+ field public static final int TETHER_ERROR_UNKNOWN_IFACE = 1; // 0x1
+ field public static final int TETHER_ERROR_UNKNOWN_TYPE = 16; // 0x10
+ field public static final int TETHER_ERROR_UNSUPPORTED = 3; // 0x3
+ field public static final int TETHER_ERROR_UNTETHER_IFACE_ERROR = 7; // 0x7
+ field public static final int TETHER_HARDWARE_OFFLOAD_FAILED = 2; // 0x2
+ field public static final int TETHER_HARDWARE_OFFLOAD_STARTED = 1; // 0x1
+ field public static final int TETHER_HARDWARE_OFFLOAD_STOPPED = 0; // 0x0
+ }
+
+ public static interface TetheringManager.OnTetheringEntitlementResultListener {
+ method public void onTetheringEntitlementResult(int);
+ }
+
+ public static interface TetheringManager.StartTetheringCallback {
+ method public default void onTetheringFailed(int);
+ method public default void onTetheringStarted();
+ }
+
+ public static interface TetheringManager.TetheringEventCallback {
+ method public default void onClientsChanged(@NonNull java.util.Collection<android.net.TetheredClient>);
+ method public default void onError(@NonNull String, int);
+ method public default void onError(@NonNull android.net.TetheringInterface, int);
+ method public default void onLocalOnlyInterfacesChanged(@NonNull java.util.List<java.lang.String>);
+ method public default void onLocalOnlyInterfacesChanged(@NonNull java.util.Set<android.net.TetheringInterface>);
+ method public default void onOffloadStatusChanged(int);
+ method public default void onTetherableInterfacesChanged(@NonNull java.util.List<java.lang.String>);
+ method public default void onTetherableInterfacesChanged(@NonNull java.util.Set<android.net.TetheringInterface>);
+ method public default void onTetheredInterfacesChanged(@NonNull java.util.List<java.lang.String>);
+ method public default void onTetheredInterfacesChanged(@NonNull java.util.Set<android.net.TetheringInterface>);
+ method public default void onTetheringSupported(boolean);
+ method public default void onUpstreamChanged(@Nullable android.net.Network);
+ }
+
+ public static class TetheringManager.TetheringRequest {
+ method @Nullable public android.net.LinkAddress getClientStaticIpv4Address();
+ method public int getConnectivityScope();
+ method @Nullable public android.net.LinkAddress getLocalIpv4Address();
+ method public boolean getShouldShowEntitlementUi();
+ method public int getTetheringType();
+ method public boolean isExemptFromEntitlementCheck();
+ }
+
+ public static class TetheringManager.TetheringRequest.Builder {
+ ctor public TetheringManager.TetheringRequest.Builder(int);
+ method @NonNull public android.net.TetheringManager.TetheringRequest build();
+ method @NonNull @RequiresPermission(android.Manifest.permission.TETHER_PRIVILEGED) public android.net.TetheringManager.TetheringRequest.Builder setConnectivityScope(int);
+ method @NonNull @RequiresPermission(android.Manifest.permission.TETHER_PRIVILEGED) public android.net.TetheringManager.TetheringRequest.Builder setExemptFromEntitlementCheck(boolean);
+ method @NonNull @RequiresPermission(android.Manifest.permission.TETHER_PRIVILEGED) public android.net.TetheringManager.TetheringRequest.Builder setShouldShowEntitlementUi(boolean);
+ method @NonNull @RequiresPermission(android.Manifest.permission.TETHER_PRIVILEGED) public android.net.TetheringManager.TetheringRequest.Builder setStaticIpv4Addresses(@NonNull android.net.LinkAddress, @NonNull android.net.LinkAddress);
+ }
+
+}
+
diff --git a/Tethering/common/TetheringLib/cronet_enabled/api/system-removed.txt b/Tethering/common/TetheringLib/cronet_enabled/api/system-removed.txt
new file mode 100644
index 0000000..d802177
--- /dev/null
+++ b/Tethering/common/TetheringLib/cronet_enabled/api/system-removed.txt
@@ -0,0 +1 @@
+// Signature format: 2.0
diff --git a/framework-t/src/android/net/nsd/NsdManager.java b/framework-t/src/android/net/nsd/NsdManager.java
index fb3b1d6..d340384 100644
--- a/framework-t/src/android/net/nsd/NsdManager.java
+++ b/framework-t/src/android/net/nsd/NsdManager.java
@@ -242,6 +242,11 @@
/** @hide */
public static final int UNREGISTER_CLIENT = 22;
+ /** @hide */
+ public static final int MDNS_MONITORING_SOCKETS_CLEANUP = 23;
+ /** @hide */
+ public static final int MDNS_DISCOVERY_MANAGER_EVENT = 24;
+
/** Dns based service discovery protocol */
public static final int PROTOCOL_DNS_SD = 0x0001;
diff --git a/service-t/src/com/android/server/NsdService.java b/service-t/src/com/android/server/NsdService.java
index b5a10e2..36c3cd4 100644
--- a/service-t/src/com/android/server/NsdService.java
+++ b/service-t/src/com/android/server/NsdService.java
@@ -17,9 +17,11 @@
package com.android.server;
import static android.net.ConnectivityManager.NETID_UNSET;
+import static android.net.nsd.NsdManager.MDNS_DISCOVERY_MANAGER_EVENT;
import static android.net.nsd.NsdManager.MDNS_SERVICE_EVENT;
import static android.provider.DeviceConfig.NAMESPACE_CONNECTIVITY;
+import android.annotation.NonNull;
import android.annotation.Nullable;
import android.content.Context;
import android.content.Intent;
@@ -45,6 +47,7 @@
import android.os.Message;
import android.os.RemoteException;
import android.os.UserHandle;
+import android.text.TextUtils;
import android.util.Log;
import android.util.Pair;
import android.util.SparseArray;
@@ -58,6 +61,9 @@
import com.android.server.connectivity.mdns.ExecutorProvider;
import com.android.server.connectivity.mdns.MdnsDiscoveryManager;
import com.android.server.connectivity.mdns.MdnsMultinetworkSocketClient;
+import com.android.server.connectivity.mdns.MdnsSearchOptions;
+import com.android.server.connectivity.mdns.MdnsServiceBrowserListener;
+import com.android.server.connectivity.mdns.MdnsServiceInfo;
import com.android.server.connectivity.mdns.MdnsSocketClientBase;
import com.android.server.connectivity.mdns.MdnsSocketProvider;
@@ -68,6 +74,9 @@
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.HashMap;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
/**
* Network Service Discovery Service handles remote service discovery operation requests by
@@ -79,6 +88,7 @@
private static final String TAG = "NsdService";
private static final String MDNS_TAG = "mDnsConnector";
private static final String MDNS_DISCOVERY_MANAGER_VERSION = "mdns_discovery_manager_version";
+ private static final String LOCAL_DOMAIN_NAME = "local";
private static final boolean DBG = Log.isLoggable(TAG, Log.DEBUG);
private static final long CLEANUP_DELAY_MS = 10000;
@@ -94,10 +104,11 @@
private final MdnsDiscoveryManager mMdnsDiscoveryManager;
@Nullable
private final MdnsSocketProvider mMdnsSocketProvider;
- // WARNING : Accessing this value in any thread is not safe, it must only be changed in the
+ // WARNING : Accessing these values in any thread is not safe, it must only be changed in the
// state machine thread. If change this outside state machine, it will need to introduce
// synchronization.
private boolean mIsDaemonStarted = false;
+ private boolean mIsMonitoringSocketsStarted = false;
/**
* Clients receiving asynchronous messages
@@ -114,6 +125,95 @@
// The count of the connected legacy clients.
private int mLegacyClientCount = 0;
+ private static class MdnsListener implements MdnsServiceBrowserListener {
+ protected final int mClientId;
+ protected final int mTransactionId;
+ @NonNull
+ protected final NsdServiceInfo mReqServiceInfo;
+ @NonNull
+ protected final String mListenedServiceType;
+
+ MdnsListener(int clientId, int transactionId, @NonNull NsdServiceInfo reqServiceInfo,
+ @NonNull String listenedServiceType) {
+ mClientId = clientId;
+ mTransactionId = transactionId;
+ mReqServiceInfo = reqServiceInfo;
+ mListenedServiceType = listenedServiceType;
+ }
+
+ @NonNull
+ public String getListenedServiceType() {
+ return mListenedServiceType;
+ }
+
+ @Override
+ public void onServiceFound(@NonNull MdnsServiceInfo serviceInfo) { }
+
+ @Override
+ public void onServiceUpdated(@NonNull MdnsServiceInfo serviceInfo) { }
+
+ @Override
+ public void onServiceRemoved(@NonNull MdnsServiceInfo serviceInfo) { }
+
+ @Override
+ public void onServiceNameDiscovered(@NonNull MdnsServiceInfo serviceInfo) { }
+
+ @Override
+ public void onServiceNameRemoved(@NonNull MdnsServiceInfo serviceInfo) { }
+
+ @Override
+ public void onSearchStoppedWithError(int error) { }
+
+ @Override
+ public void onSearchFailedToStart() { }
+
+ @Override
+ public void onDiscoveryQuerySent(@NonNull List<String> subtypes, int transactionId) { }
+
+ @Override
+ public void onFailedToParseMdnsResponse(int receivedPacketNumber, int errorCode) { }
+ }
+
+ private class DiscoveryListener extends MdnsListener {
+
+ DiscoveryListener(int clientId, int transactionId, @NonNull NsdServiceInfo reqServiceInfo,
+ @NonNull String listenServiceType) {
+ super(clientId, transactionId, reqServiceInfo, listenServiceType);
+ }
+
+ @Override
+ public void onServiceNameDiscovered(@NonNull MdnsServiceInfo serviceInfo) {
+ mNsdStateMachine.sendMessage(MDNS_DISCOVERY_MANAGER_EVENT, mTransactionId,
+ NsdManager.SERVICE_FOUND,
+ new MdnsEvent(mClientId, mReqServiceInfo.getServiceType(), serviceInfo));
+ }
+
+ @Override
+ public void onServiceNameRemoved(@NonNull MdnsServiceInfo serviceInfo) {
+ mNsdStateMachine.sendMessage(MDNS_DISCOVERY_MANAGER_EVENT, mTransactionId,
+ NsdManager.SERVICE_LOST,
+ new MdnsEvent(mClientId, mReqServiceInfo.getServiceType(), serviceInfo));
+ }
+ }
+
+ /**
+ * Data class of mdns service callback information.
+ */
+ private static class MdnsEvent {
+ final int mClientId;
+ @NonNull
+ final String mRequestedServiceType;
+ @NonNull
+ final MdnsServiceInfo mMdnsServiceInfo;
+
+ MdnsEvent(int clientId, @NonNull String requestedServiceType,
+ @NonNull MdnsServiceInfo mdnsServiceInfo) {
+ mClientId = clientId;
+ mRequestedServiceType = requestedServiceType;
+ mMdnsServiceInfo = mdnsServiceInfo;
+ }
+ }
+
private class NsdStateMachine extends StateMachine {
private final DefaultState mDefaultState = new DefaultState();
@@ -164,6 +264,31 @@
this.removeMessages(NsdManager.DAEMON_CLEANUP);
}
+ private void maybeStartMonitoringSockets() {
+ if (mIsMonitoringSocketsStarted) {
+ if (DBG) Log.d(TAG, "Socket monitoring is already started.");
+ return;
+ }
+
+ mMdnsSocketProvider.startMonitoringSockets();
+ mIsMonitoringSocketsStarted = true;
+ }
+
+ private void maybeStopMonitoringSockets() {
+ if (!mIsMonitoringSocketsStarted) {
+ if (DBG) Log.d(TAG, "Socket monitoring has not been started.");
+ return;
+ }
+ mMdnsSocketProvider.stopMonitoringSockets();
+ mIsMonitoringSocketsStarted = false;
+ }
+
+ private void maybeStopMonitoringSocketsIfNoActiveRequest() {
+ if (!isAnyRequestActive()) {
+ maybeStopMonitoringSockets();
+ }
+ }
+
NsdStateMachine(String name, Handler handler) {
super(name, handler);
addState(mDefaultState);
@@ -195,11 +320,17 @@
final NsdServiceConnector connector = (NsdServiceConnector) msg.obj;
cInfo = mClients.remove(connector);
if (cInfo != null) {
+ if (mMdnsDiscoveryManager != null) {
+ cInfo.unregisterAllListeners();
+ }
cInfo.expungeAllRequests();
if (cInfo.isLegacy()) {
mLegacyClientCount -= 1;
}
}
+ if (mMdnsDiscoveryManager != null) {
+ maybeStopMonitoringSocketsIfNoActiveRequest();
+ }
maybeScheduleStop();
break;
case NsdManager.DISCOVER_SERVICES:
@@ -251,6 +382,9 @@
maybeStartDaemon();
}
break;
+ case NsdManager.MDNS_MONITORING_SOCKETS_CLEANUP:
+ maybeStopMonitoringSockets();
+ break;
default:
Log.e(TAG, "Unhandled " + msg);
return NOT_HANDLED;
@@ -300,6 +434,47 @@
maybeScheduleStop();
}
+ private void storeListenerMap(int clientId, int transactionId, MdnsListener listener,
+ ClientInfo clientInfo) {
+ clientInfo.mClientIds.put(clientId, transactionId);
+ clientInfo.mListeners.put(clientId, listener);
+ mIdToClientInfoMap.put(transactionId, clientInfo);
+ removeMessages(NsdManager.MDNS_MONITORING_SOCKETS_CLEANUP);
+ }
+
+ private void removeListenerMap(int clientId, int transactionId, ClientInfo clientInfo) {
+ clientInfo.mClientIds.delete(clientId);
+ clientInfo.mListeners.delete(clientId);
+ mIdToClientInfoMap.remove(transactionId);
+ maybeStopMonitoringSocketsIfNoActiveRequest();
+ }
+
+ /**
+ * Check the given service type is valid and construct it to a service type
+ * which can use for discovery / resolution service.
+ *
+ * <p> The valid service type should be 2 labels, or 3 labels if the query is for a
+ * subtype (see RFC6763 7.1). Each label is up to 63 characters and must start with an
+ * underscore; they are alphanumerical characters or dashes or underscore, except the
+ * last one that is just alphanumerical. The last label must be _tcp or _udp.
+ *
+ * @param serviceType the request service type for discovery / resolution service
+ * @return constructed service type or null if the given service type is invalid.
+ */
+ @Nullable
+ private String constructServiceType(String serviceType) {
+ if (TextUtils.isEmpty(serviceType)) return null;
+
+ final Pattern serviceTypePattern = Pattern.compile(
+ "^(_[a-zA-Z0-9-_]{1,61}[a-zA-Z0-9]\\.)?"
+ + "(_[a-zA-Z0-9-_]{1,61}[a-zA-Z0-9]\\._(?:tcp|udp))$");
+ final Matcher matcher = serviceTypePattern.matcher(serviceType);
+ if (!matcher.matches()) return null;
+ return matcher.group(1) == null
+ ? serviceType + ".local"
+ : matcher.group(1) + "._sub" + matcher.group(2) + ".local";
+ }
+
@Override
public boolean processMessage(Message msg) {
final ClientInfo clientInfo;
@@ -325,19 +500,40 @@
break;
}
- maybeStartDaemon();
+ final NsdServiceInfo info = args.serviceInfo;
id = getUniqueId();
- if (discoverServices(id, args.serviceInfo)) {
- if (DBG) {
- Log.d(TAG, "Discover " + msg.arg2 + " " + id
- + args.serviceInfo.getServiceType());
+ if (mMdnsDiscoveryManager != null) {
+ final String serviceType = constructServiceType(info.getServiceType());
+ if (serviceType == null) {
+ clientInfo.onDiscoverServicesFailed(clientId,
+ NsdManager.FAILURE_INTERNAL_ERROR);
+ break;
}
- storeRequestMap(clientId, id, clientInfo, msg.what);
- clientInfo.onDiscoverServicesStarted(clientId, args.serviceInfo);
+
+ maybeStartMonitoringSockets();
+ final MdnsListener listener =
+ new DiscoveryListener(clientId, id, info, serviceType);
+ final MdnsSearchOptions options = MdnsSearchOptions.newBuilder()
+ .setNetwork(info.getNetwork())
+ .setIsPassiveMode(true)
+ .build();
+ mMdnsDiscoveryManager.registerListener(serviceType, listener, options);
+ storeListenerMap(clientId, id, listener, clientInfo);
+ clientInfo.onDiscoverServicesStarted(clientId, info);
} else {
- stopServiceDiscovery(id);
- clientInfo.onDiscoverServicesFailed(clientId,
- NsdManager.FAILURE_INTERNAL_ERROR);
+ maybeStartDaemon();
+ if (discoverServices(id, info)) {
+ if (DBG) {
+ Log.d(TAG, "Discover " + msg.arg2 + " " + id
+ + info.getServiceType());
+ }
+ storeRequestMap(clientId, id, clientInfo, msg.what);
+ clientInfo.onDiscoverServicesStarted(clientId, info);
+ } else {
+ stopServiceDiscovery(id);
+ clientInfo.onDiscoverServicesFailed(clientId,
+ NsdManager.FAILURE_INTERNAL_ERROR);
+ }
}
break;
case NsdManager.STOP_DISCOVERY:
@@ -359,12 +555,25 @@
clientId, NsdManager.FAILURE_INTERNAL_ERROR);
break;
}
- removeRequestMap(clientId, id, clientInfo);
- if (stopServiceDiscovery(id)) {
+ if (mMdnsDiscoveryManager != null) {
+ final MdnsListener listener = clientInfo.mListeners.get(clientId);
+ if (listener == null) {
+ clientInfo.onStopDiscoveryFailed(
+ clientId, NsdManager.FAILURE_INTERNAL_ERROR);
+ break;
+ }
+ mMdnsDiscoveryManager.unregisterListener(
+ listener.getListenedServiceType(), listener);
+ removeListenerMap(clientId, id, clientInfo);
clientInfo.onStopDiscoverySucceeded(clientId);
} else {
- clientInfo.onStopDiscoveryFailed(
- clientId, NsdManager.FAILURE_INTERNAL_ERROR);
+ removeRequestMap(clientId, id, clientInfo);
+ if (stopServiceDiscovery(id)) {
+ clientInfo.onStopDiscoverySucceeded(clientId);
+ } else {
+ clientInfo.onStopDiscoveryFailed(
+ clientId, NsdManager.FAILURE_INTERNAL_ERROR);
+ }
}
break;
case NsdManager.REGISTER_SERVICE:
@@ -450,6 +659,11 @@
return NOT_HANDLED;
}
break;
+ case MDNS_DISCOVERY_MANAGER_EVENT:
+ if (!handleMdnsDiscoveryManagerEvent(msg.arg1, msg.arg2, msg.obj)) {
+ return NOT_HANDLED;
+ }
+ break;
default:
return NOT_HANDLED;
}
@@ -612,6 +826,48 @@
}
return true;
}
+
+ private NsdServiceInfo buildNsdServiceInfoFromMdnsEvent(final MdnsEvent event) {
+ final MdnsServiceInfo serviceInfo = event.mMdnsServiceInfo;
+ final String serviceType = event.mRequestedServiceType;
+ final String serviceName = serviceInfo.getServiceInstanceName();
+ final NsdServiceInfo servInfo = new NsdServiceInfo(serviceName, serviceType);
+ final Network network = serviceInfo.getNetwork();
+ setServiceNetworkForCallback(
+ servInfo,
+ network == null ? NETID_UNSET : network.netId,
+ serviceInfo.getInterfaceIndex());
+ return servInfo;
+ }
+
+ private boolean handleMdnsDiscoveryManagerEvent(
+ int transactionId, int code, Object obj) {
+ final ClientInfo clientInfo = mIdToClientInfoMap.get(transactionId);
+ if (clientInfo == null) {
+ Log.e(TAG, String.format(
+ "id %d for %d has no client mapping", transactionId, code));
+ return false;
+ }
+
+ final MdnsEvent event = (MdnsEvent) obj;
+ final int clientId = event.mClientId;
+ final NsdServiceInfo info = buildNsdServiceInfoFromMdnsEvent(event);
+ if (DBG) {
+ Log.d(TAG, String.format("MdnsDiscoveryManager event code=%s transactionId=%d",
+ NsdManager.nameOf(code), transactionId));
+ }
+ switch (code) {
+ case NsdManager.SERVICE_FOUND:
+ clientInfo.onServiceFound(clientId, info);
+ break;
+ case NsdManager.SERVICE_LOST:
+ clientInfo.onServiceLost(clientId, info);
+ break;
+ default:
+ return false;
+ }
+ return true;
+ }
}
}
@@ -982,6 +1238,9 @@
/* A map from client id to the type of the request we had received */
private final SparseIntArray mClientRequests = new SparseIntArray();
+ /* A map from client id to the MdnsListener */
+ private final SparseArray<MdnsListener> mListeners = new SparseArray<>();
+
// The target SDK of this client < Build.VERSION_CODES.S
private boolean mIsLegacy = false;
@@ -1043,6 +1302,15 @@
mClientRequests.clear();
}
+ void unregisterAllListeners() {
+ for (int i = 0; i < mListeners.size(); i++) {
+ final MdnsListener listener = mListeners.valueAt(i);
+ mMdnsDiscoveryManager.unregisterListener(
+ listener.getListenedServiceType(), listener);
+ }
+ mListeners.clear();
+ }
+
// mClientIds is a sparse array of listener id -> mDnsClient id. For a given mDnsClient id,
// return the corresponding listener id. mDnsClient id is also called a global id.
private int getClientId(final int globalId) {
diff --git a/service/src/com/android/server/connectivity/KeepaliveTracker.java b/service/src/com/android/server/connectivity/KeepaliveTracker.java
index 3b58823..9c36760 100644
--- a/service/src/com/android/server/connectivity/KeepaliveTracker.java
+++ b/service/src/com/android/server/connectivity/KeepaliveTracker.java
@@ -33,15 +33,27 @@
import static android.net.SocketKeepalive.MIN_INTERVAL_SEC;
import static android.net.SocketKeepalive.NO_KEEPALIVE;
import static android.net.SocketKeepalive.SUCCESS;
+import static android.system.OsConstants.AF_INET;
+import static android.system.OsConstants.AF_INET6;
+import static android.system.OsConstants.SOL_SOCKET;
+import static android.system.OsConstants.SO_SNDTIMEO;
+
+import static com.android.net.module.util.netlink.NetlinkConstants.NLMSG_DONE;
+import static com.android.net.module.util.netlink.NetlinkConstants.SOCKDIAG_MSG_HEADER_SIZE;
+import static com.android.net.module.util.netlink.NetlinkConstants.SOCK_DIAG_BY_FAMILY;
+import static com.android.net.module.util.netlink.NetlinkUtils.IO_TIMEOUT_MS;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.content.Context;
+import android.content.res.Resources;
import android.net.ConnectivityResources;
+import android.net.INetd;
import android.net.ISocketKeepaliveCallback;
import android.net.InetAddresses;
import android.net.InvalidPacketException;
import android.net.KeepalivePacketData;
+import android.net.MarkMaskParcel;
import android.net.NattKeepalivePacketData;
import android.net.NetworkAgent;
import android.net.SocketKeepalive.InvalidSocketException;
@@ -55,18 +67,29 @@
import android.os.RemoteException;
import android.system.ErrnoException;
import android.system.Os;
+import android.system.StructTimeval;
import android.util.Log;
import android.util.Pair;
+import android.util.SparseArray;
import com.android.connectivity.resources.R;
+import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.util.IndentingPrintWriter;
import com.android.net.module.util.HexDump;
import com.android.net.module.util.IpUtils;
+import com.android.net.module.util.SocketUtils;
+import com.android.net.module.util.netlink.InetDiagMessage;
+import com.android.net.module.util.netlink.NetlinkUtils;
+import com.android.net.module.util.netlink.StructNlAttr;
import java.io.FileDescriptor;
+import java.io.InterruptedIOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
+import java.net.SocketException;
+import java.nio.BufferUnderflowException;
+import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
@@ -84,6 +107,7 @@
private static final boolean DBG = false;
public static final String PERMISSION = android.Manifest.permission.PACKET_KEEPALIVE_OFFLOAD;
+ private static final int[] ADDRESS_FAMILIES = new int[] {AF_INET6, AF_INET};
/** Keeps track of keepalive requests. */
private final HashMap <NetworkAgentInfo, HashMap<Integer, KeepaliveInfo>> mKeepalives =
@@ -107,17 +131,35 @@
// Allowed unprivileged keepalive slots per uid. Caller's permission will be enforced if
// the number of remaining keepalive slots is less than or equal to the threshold.
private final int mAllowedUnprivilegedSlotsForUid;
+ /**
+ * The {@code inetDiagReqV2} messages for different IP family.
+ *
+ * Key: Ip family type.
+ * Value: Bytes array represent the {@code inetDiagReqV2}.
+ *
+ * This should only be accessed in the connectivity service handler thread.
+ */
+ private final SparseArray<byte[]> mSockDiagMsg = new SparseArray<>();
+ private final Dependencies mDependencies;
+ private final INetd mNetd;
public KeepaliveTracker(Context context, Handler handler) {
+ this(context, handler, new Dependencies(context));
+ }
+
+ @VisibleForTesting
+ public KeepaliveTracker(Context context, Handler handler, Dependencies dependencies) {
mConnectivityServiceHandler = handler;
mTcpController = new TcpKeepaliveController(handler);
mContext = context;
- mSupportedKeepalives = KeepaliveUtils.getSupportedKeepalives(mContext);
+ mDependencies = dependencies;
+ mSupportedKeepalives = mDependencies.getSupportedKeepalives();
+ mNetd = mDependencies.getNetd();
- final ConnectivityResources res = new ConnectivityResources(mContext);
- mReservedPrivilegedSlots = res.get().getInteger(
+ final Resources res = mDependencies.newConnectivityResources();
+ mReservedPrivilegedSlots = res.getInteger(
R.integer.config_reservedPrivilegedKeepaliveSlots);
- mAllowedUnprivilegedSlotsForUid = res.get().getInteger(
+ mAllowedUnprivilegedSlotsForUid = res.getInteger(
R.integer.config_allowedUnprivilegedKeepalivePerUid);
}
@@ -739,6 +781,9 @@
return true;
}
+ /**
+ * Dump KeepaliveTracker state.
+ */
public void dump(IndentingPrintWriter pw) {
pw.println("Supported Socket keepalives: " + Arrays.toString(mSupportedKeepalives));
pw.println("Reserved Privileged keepalives: " + mReservedPrivilegedSlots);
@@ -756,4 +801,196 @@
}
pw.decreaseIndent();
}
+
+ /**
+ * Dependencies class for testing.
+ */
+ @VisibleForTesting
+ public static class Dependencies {
+ private final Context mContext;
+
+ public Dependencies(final Context context) {
+ mContext = context;
+ }
+
+ /**
+ * Create a netlink socket connected to the kernel.
+ *
+ * @return fd the fileDescriptor of the socket.
+ */
+ public FileDescriptor createConnectedNetlinkSocket()
+ throws ErrnoException, SocketException {
+ final FileDescriptor fd = NetlinkUtils.createNetLinkInetDiagSocket();
+ NetlinkUtils.connectSocketToNetlink(fd);
+ Os.setsockoptTimeval(fd, SOL_SOCKET, SO_SNDTIMEO,
+ StructTimeval.fromMillis(IO_TIMEOUT_MS));
+ return fd;
+ }
+
+ /**
+ * Send composed message request to kernel.
+ *
+ * The given FileDescriptor is expected to be created by
+ * {@link #createConnectedNetlinkSocket} or equivalent way.
+ *
+ * @param fd a netlink socket {@code FileDescriptor} connected to the kernel.
+ * @param msg the byte array representing the request message to write to kernel.
+ */
+ public void sendRequest(@NonNull final FileDescriptor fd,
+ @NonNull final byte[] msg)
+ throws ErrnoException, InterruptedIOException {
+ Os.write(fd, msg, 0 /* byteOffset */, msg.length);
+ }
+
+ /**
+ * Get an INetd connector.
+ */
+ public INetd getNetd() {
+ return INetd.Stub.asInterface(
+ (IBinder) mContext.getSystemService(Context.NETD_SERVICE));
+ }
+
+ /**
+ * Receive the response message from kernel via given {@code FileDescriptor}.
+ * The usage should follow the {@code #sendRequest} call with the same
+ * FileDescriptor.
+ *
+ * The overall response may be large but the individual messages should not be
+ * excessively large(8-16kB) because trying to get the kernel to return
+ * everything in one big buffer is inefficient as it forces the kernel to allocate
+ * large chunks of linearly physically contiguous memory. The usage should iterate the
+ * call of this method until the end of the overall message.
+ *
+ * The default receiving buffer size should be small enough that it is always
+ * processed within the {@link NetlinkUtils#IO_TIMEOUT_MS} timeout.
+ */
+ public ByteBuffer recvSockDiagResponse(@NonNull final FileDescriptor fd)
+ throws ErrnoException, InterruptedIOException {
+ return NetlinkUtils.recvMessage(
+ fd, NetlinkUtils.DEFAULT_RECV_BUFSIZE, NetlinkUtils.IO_TIMEOUT_MS);
+ }
+
+ /**
+ * Read supported keepalive count for each transport type from overlay resource.
+ */
+ public int[] getSupportedKeepalives() {
+ return KeepaliveUtils.getSupportedKeepalives(mContext);
+ }
+
+ /**
+ * Construct a new Resource from a new ConnectivityResources.
+ */
+ public Resources newConnectivityResources() {
+ final ConnectivityResources resources = new ConnectivityResources(mContext);
+ return resources.get();
+ }
+ }
+
+ private void ensureRunningOnHandlerThread() {
+ if (mConnectivityServiceHandler.getLooper().getThread() != Thread.currentThread()) {
+ throw new IllegalStateException(
+ "Not running on handler thread: " + Thread.currentThread().getName());
+ }
+ }
+
+ @VisibleForTesting
+ boolean isAnyTcpSocketConnected(int netId) {
+ FileDescriptor fd = null;
+
+ try {
+ fd = mDependencies.createConnectedNetlinkSocket();
+
+ // Get network mask
+ final MarkMaskParcel parcel = mNetd.getFwmarkForNetwork(netId);
+ final int networkMark = (parcel != null) ? parcel.mark : NetlinkUtils.UNKNOWN_MARK;
+ final int networkMask = (parcel != null) ? parcel.mask : NetlinkUtils.NULL_MASK;
+
+ // Send request for each IP family
+ for (final int family : ADDRESS_FAMILIES) {
+ if (isAnyTcpSocketConnectedForFamily(fd, family, networkMark, networkMask)) {
+ return true;
+ }
+ }
+ } catch (ErrnoException | SocketException | InterruptedIOException | RemoteException e) {
+ Log.e(TAG, "Fail to get socket info via netlink.", e);
+ } finally {
+ SocketUtils.closeSocketQuietly(fd);
+ }
+
+ return false;
+ }
+
+ private boolean isAnyTcpSocketConnectedForFamily(FileDescriptor fd, int family, int networkMark,
+ int networkMask) throws ErrnoException, InterruptedIOException {
+ ensureRunningOnHandlerThread();
+ // Build SocketDiag messages and cache it.
+ if (mSockDiagMsg.get(family) == null) {
+ mSockDiagMsg.put(family, InetDiagMessage.buildInetDiagReqForAliveTcpSockets(family));
+ }
+ mDependencies.sendRequest(fd, mSockDiagMsg.get(family));
+
+ // Iteration limitation as a protection to avoid possible infinite loops.
+ // DEFAULT_RECV_BUFSIZE could read more than 20 sockets per time. Max iteration
+ // should be enough to go through reasonable TCP sockets in the device.
+ final int maxIteration = 100;
+ int parsingIteration = 0;
+ while (parsingIteration < maxIteration) {
+ final ByteBuffer bytes = mDependencies.recvSockDiagResponse(fd);
+
+ try {
+ while (NetlinkUtils.enoughBytesRemainForValidNlMsg(bytes)) {
+ final int startPos = bytes.position();
+
+ final int nlmsgLen = bytes.getInt();
+ final int nlmsgType = bytes.getShort();
+ if (isEndOfMessageOrError(nlmsgType)) return false;
+ // TODO: Parse InetDiagMessage to get uid and dst address information to filter
+ // socket via NetlinkMessage.parse.
+
+ // Skip the header to move to data part.
+ bytes.position(startPos + SOCKDIAG_MSG_HEADER_SIZE);
+
+ if (isTargetTcpSocket(bytes, nlmsgLen, networkMark, networkMask)) {
+ return true;
+ }
+ }
+ } catch (BufferUnderflowException e) {
+ // The exception happens in random place in either header position or any data
+ // position. Partial bytes from the middle of the byte buffer may not be enough to
+ // clarify, so print out the content before the error to possibly prevent printing
+ // the whole 8K buffer.
+ final int exceptionPos = bytes.position();
+ final String hex = HexDump.dumpHexString(bytes.array(), 0, exceptionPos);
+ Log.e(TAG, "Unexpected socket info parsing: " + hex, e);
+ }
+
+ parsingIteration++;
+ }
+ return false;
+ }
+
+ private boolean isEndOfMessageOrError(int nlmsgType) {
+ return nlmsgType == NLMSG_DONE || nlmsgType != SOCK_DIAG_BY_FAMILY;
+ }
+
+ private boolean isTargetTcpSocket(@NonNull ByteBuffer bytes, int nlmsgLen, int networkMark,
+ int networkMask) {
+ final int mark = readSocketDataAndReturnMark(bytes, nlmsgLen);
+ return (mark & networkMask) == networkMark;
+ }
+
+ private int readSocketDataAndReturnMark(@NonNull ByteBuffer bytes, int nlmsgLen) {
+ final int nextMsgOffset = bytes.position() + nlmsgLen - SOCKDIAG_MSG_HEADER_SIZE;
+ int mark = NetlinkUtils.INIT_MARK_VALUE;
+ // Get socket mark
+ // TODO: Add a parsing method in NetlinkMessage.parse to support this to skip the remaining
+ // data.
+ while (bytes.position() < nextMsgOffset) {
+ final StructNlAttr nlattr = StructNlAttr.parse(bytes);
+ if (nlattr != null && nlattr.nla_type == NetlinkUtils.INET_DIAG_MARK) {
+ mark = nlattr.getValueAsInteger();
+ }
+ }
+ return mark;
+ }
}
diff --git a/tests/unit/java/com/android/server/ConnectivityServiceTest.java b/tests/unit/java/com/android/server/ConnectivityServiceTest.java
index b5373a4..17e769c 100755
--- a/tests/unit/java/com/android/server/ConnectivityServiceTest.java
+++ b/tests/unit/java/com/android/server/ConnectivityServiceTest.java
@@ -539,9 +539,9 @@
private ConnectivityServiceDependencies mDeps;
private ConnectivityService mService;
private WrappedConnectivityManager mCm;
- private TestNetworkAgentWrapper mWiFiNetworkAgent;
- private TestNetworkAgentWrapper mCellNetworkAgent;
- private TestNetworkAgentWrapper mEthernetNetworkAgent;
+ private TestNetworkAgentWrapper mWiFiAgent;
+ private TestNetworkAgentWrapper mCellAgent;
+ private TestNetworkAgentWrapper mEthernetAgent;
private MockVpn mMockVpn;
private Context mContext;
private NetworkPolicyCallback mPolicyCallback;
@@ -884,9 +884,9 @@
private void waitForIdle() {
HandlerUtils.waitForIdle(mCsHandlerThread, TIMEOUT_MS);
- waitForIdle(mCellNetworkAgent, TIMEOUT_MS);
- waitForIdle(mWiFiNetworkAgent, TIMEOUT_MS);
- waitForIdle(mEthernetNetworkAgent, TIMEOUT_MS);
+ waitForIdle(mCellAgent, TIMEOUT_MS);
+ waitForIdle(mWiFiAgent, TIMEOUT_MS);
+ waitForIdle(mEthernetAgent, TIMEOUT_MS);
HandlerUtils.waitForIdle(mCsHandlerThread, TIMEOUT_MS);
HandlerUtils.waitForIdle(ConnectivityThread.get(), TIMEOUT_MS);
}
@@ -909,15 +909,15 @@
// Bring up a network that we can use to send messages to ConnectivityService.
ExpectedBroadcast b = expectConnectivityAction(TYPE_WIFI, DetailedState.CONNECTED);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
b.expectBroadcast();
- Network n = mWiFiNetworkAgent.getNetwork();
+ Network n = mWiFiAgent.getNetwork();
assertNotNull(n);
// Tests that calling waitForIdle waits for messages to be processed.
for (int i = 0; i < attempts; i++) {
- mWiFiNetworkAgent.setSignalStrength(i);
+ mWiFiAgent.setSignalStrength(i);
waitForIdle();
assertEquals(i, mCm.getNetworkCapabilities(n).getSignalStrength());
}
@@ -929,16 +929,16 @@
public void verifyThatNotWaitingForIdleCausesRaceConditions() throws Exception {
// Bring up a network that we can use to send messages to ConnectivityService.
ExpectedBroadcast b = expectConnectivityAction(TYPE_WIFI, DetailedState.CONNECTED);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
b.expectBroadcast();
- Network n = mWiFiNetworkAgent.getNetwork();
+ Network n = mWiFiAgent.getNetwork();
assertNotNull(n);
// Ensure that not calling waitForIdle causes a race condition.
final int attempts = 50; // Causes the test to take about 200ms on bullhead-eng.
for (int i = 0; i < attempts; i++) {
- mWiFiNetworkAgent.setSignalStrength(i);
+ mWiFiAgent.setSignalStrength(i);
if (i != mCm.getNetworkCapabilities(n).getSignalStrength()) {
// We hit a race condition, as expected. Pass the test.
return;
@@ -2125,17 +2125,17 @@
unregisterDefaultNetworkCallbacks();
maybeTearDownEnterpriseNetwork();
setAlwaysOnNetworks(false);
- if (mCellNetworkAgent != null) {
- mCellNetworkAgent.disconnect();
- mCellNetworkAgent = null;
+ if (mCellAgent != null) {
+ mCellAgent.disconnect();
+ mCellAgent = null;
}
- if (mWiFiNetworkAgent != null) {
- mWiFiNetworkAgent.disconnect();
- mWiFiNetworkAgent = null;
+ if (mWiFiAgent != null) {
+ mWiFiAgent.disconnect();
+ mWiFiAgent = null;
}
- if (mEthernetNetworkAgent != null) {
- mEthernetNetworkAgent.disconnect();
- mEthernetNetworkAgent = null;
+ if (mEthernetAgent != null) {
+ mEthernetAgent.disconnect();
+ mEthernetAgent = null;
}
if (mQosCallbackMockHelper != null) {
@@ -2198,13 +2198,13 @@
}
switch (transport) {
case TRANSPORT_WIFI:
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
break;
case TRANSPORT_CELLULAR:
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
break;
case TRANSPORT_ETHERNET:
- assertEquals(mEthernetNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mEthernetAgent.getNetwork(), mCm.getActiveNetwork());
break;
default:
break;
@@ -2378,10 +2378,10 @@
@Test
public void testNetworkFeature() throws Exception {
// Connect the cell agent and wait for the connected broadcast.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.addCapability(NET_CAPABILITY_SUPL);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.addCapability(NET_CAPABILITY_SUPL);
ExpectedBroadcast b = expectConnectivityAction(TYPE_MOBILE, DetailedState.CONNECTED);
- mCellNetworkAgent.connect(true);
+ mCellAgent.connect(true);
b.expectBroadcast();
// Build legacy request for SUPL.
@@ -2395,45 +2395,45 @@
b = registerConnectivityBroadcast(1);
final TestNetworkCallback callback = new TestNetworkCallback();
mCm.requestNetwork(legacyRequest, callback);
- callback.expect(AVAILABLE, mCellNetworkAgent);
+ callback.expect(AVAILABLE, mCellAgent);
mCm.unregisterNetworkCallback(callback);
b.expectNoBroadcast(800); // 800ms long enough to at least flake if this is sent
// Disconnect the network and expect mobile disconnected broadcast.
b = expectConnectivityAction(TYPE_MOBILE, DetailedState.DISCONNECTED);
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
b.expectBroadcast();
}
@Test
public void testLingering() throws Exception {
verifyNoNetwork();
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
assertNull(mCm.getActiveNetworkInfo());
assertNull(mCm.getActiveNetwork());
// Test bringing up validated cellular.
ExpectedBroadcast b = expectConnectivityAction(TYPE_MOBILE, DetailedState.CONNECTED);
- mCellNetworkAgent.connect(true);
+ mCellAgent.connect(true);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_CELLULAR);
assertLength(2, mCm.getAllNetworks());
- assertTrue(mCm.getAllNetworks()[0].equals(mCm.getActiveNetwork()) ||
- mCm.getAllNetworks()[1].equals(mCm.getActiveNetwork()));
- assertTrue(mCm.getAllNetworks()[0].equals(mWiFiNetworkAgent.getNetwork()) ||
- mCm.getAllNetworks()[1].equals(mWiFiNetworkAgent.getNetwork()));
+ assertTrue(mCm.getAllNetworks()[0].equals(mCm.getActiveNetwork())
+ || mCm.getAllNetworks()[1].equals(mCm.getActiveNetwork()));
+ assertTrue(mCm.getAllNetworks()[0].equals(mWiFiAgent.getNetwork())
+ || mCm.getAllNetworks()[1].equals(mWiFiAgent.getNetwork()));
// Test bringing up validated WiFi.
b = registerConnectivityBroadcast(2);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent.connect(true);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_WIFI);
assertLength(2, mCm.getAllNetworks());
- assertTrue(mCm.getAllNetworks()[0].equals(mCm.getActiveNetwork()) ||
- mCm.getAllNetworks()[1].equals(mCm.getActiveNetwork()));
- assertTrue(mCm.getAllNetworks()[0].equals(mCellNetworkAgent.getNetwork()) ||
- mCm.getAllNetworks()[1].equals(mCellNetworkAgent.getNetwork()));
+ assertTrue(mCm.getAllNetworks()[0].equals(mCm.getActiveNetwork())
+ || mCm.getAllNetworks()[1].equals(mCm.getActiveNetwork()));
+ assertTrue(mCm.getAllNetworks()[0].equals(mCellAgent.getNetwork())
+ || mCm.getAllNetworks()[1].equals(mCellAgent.getNetwork()));
// Test cellular linger timeout.
- mCellNetworkAgent.expectDisconnected();
+ mCellAgent.expectDisconnected();
waitForIdle();
assertLength(1, mCm.getAllNetworks());
verifyActiveNetwork(TRANSPORT_WIFI);
@@ -2441,7 +2441,7 @@
assertEquals(mCm.getAllNetworks()[0], mCm.getActiveNetwork());
// Test WiFi disconnect.
b = registerConnectivityBroadcast(1);
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
b.expectBroadcast();
verifyNoNetwork();
}
@@ -2458,43 +2458,43 @@
// 1. Create a network that is not requested by anyone, and does not satisfy any of the
// default requests. Verify that the network will be inactive instead of torn down.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connectWithoutInternet();
- listenCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connectWithoutInternet();
+ listenCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
listenCallback.assertNoCallback();
// Verify that the network will be torn down after nascent expiry. A small period of time
// is added in case of flakiness.
final int nascentTimeoutMs =
mService.mNascentDelayMs + mService.mNascentDelayMs / 4;
- listenCallback.expect(LOST, mWiFiNetworkAgent, nascentTimeoutMs);
+ listenCallback.expect(LOST, mWiFiAgent, nascentTimeoutMs);
// 2. Create a network that is satisfied by a request comes later.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connectWithoutInternet();
- listenCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connectWithoutInternet();
+ listenCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
final NetworkRequest wifiRequest = new NetworkRequest.Builder()
.addTransportType(TRANSPORT_WIFI).build();
final TestNetworkCallback wifiCallback = new TestNetworkCallback();
mCm.requestNetwork(wifiRequest, wifiCallback);
- wifiCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ wifiCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
// Verify that the network will be kept since the request is still satisfied. And is able
// to get disconnected as usual if the request is released after the nascent timer expires.
listenCallback.assertNoCallback(nascentTimeoutMs);
mCm.unregisterNetworkCallback(wifiCallback);
- listenCallback.expect(LOST, mWiFiNetworkAgent);
+ listenCallback.expect(LOST, mWiFiAgent);
// 3. Create a network that is satisfied by a request comes later.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connectWithoutInternet();
- listenCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connectWithoutInternet();
+ listenCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
mCm.requestNetwork(wifiRequest, wifiCallback);
- wifiCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ wifiCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
// Verify that the network will still be torn down after the request gets removed.
mCm.unregisterNetworkCallback(wifiCallback);
- listenCallback.expect(LOST, mWiFiNetworkAgent);
+ listenCallback.expect(LOST, mWiFiAgent);
// There is no need to ensure that LOSING is never sent in the common case that the
// network immediately satisfies a request that was already present, because it is already
@@ -2527,20 +2527,20 @@
.addCapability(NET_CAPABILITY_FOREGROUND).build(), fgMobileListenCallback);
// Connect wifi, which satisfies default request.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
- wifiListenCallback.expectAvailableThenValidatedCallbacks(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
+ wifiListenCallback.expectAvailableThenValidatedCallbacks(mWiFiAgent);
// Connect a cellular network, verify that satisfies only the background callback.
setAlwaysOnNetworks(true);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- bgMobileListenCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ bgMobileListenCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
fgMobileListenCallback.assertNoCallback();
- assertFalse(isForegroundNetwork(mCellNetworkAgent));
+ assertFalse(isForegroundNetwork(mCellAgent));
- mCellNetworkAgent.disconnect();
- bgMobileListenCallback.expect(LOST, mCellNetworkAgent);
+ mCellAgent.disconnect();
+ bgMobileListenCallback.expect(LOST, mCellAgent);
fgMobileListenCallback.assertNoCallback();
mCm.unregisterNetworkCallback(wifiListenCallback);
@@ -2605,34 +2605,34 @@
final boolean cellRadioTimesharingCapable) throws Exception {
mService.mCellularRadioTimesharingCapable = cellRadioTimesharingCapable;
// Test bringing up unvalidated WiFi
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
ExpectedBroadcast b = registerConnectivityBroadcast(1);
- mWiFiNetworkAgent.connect(false);
+ mWiFiAgent.connect(false);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_WIFI);
// Test bringing up unvalidated cellular
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(false);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(false);
waitForIdle();
verifyActiveNetwork(TRANSPORT_WIFI);
// Test cellular disconnect.
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
waitForIdle();
verifyActiveNetwork(TRANSPORT_WIFI);
// Test bringing up validated cellular
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
b = registerConnectivityBroadcast(2);
- mCellNetworkAgent.connect(true);
+ mCellAgent.connect(true);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_CELLULAR);
// Test cellular disconnect.
b = registerConnectivityBroadcast(2);
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_WIFI);
// Test WiFi disconnect.
b = registerConnectivityBroadcast(1);
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
b.expectBroadcast();
verifyNoNetwork();
}
@@ -2653,25 +2653,25 @@
final boolean cellRadioTimesharingCapable) throws Exception {
mService.mCellularRadioTimesharingCapable = cellRadioTimesharingCapable;
// Test bringing up unvalidated cellular.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
ExpectedBroadcast b = registerConnectivityBroadcast(1);
- mCellNetworkAgent.connect(false);
+ mCellAgent.connect(false);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_CELLULAR);
// Test bringing up unvalidated WiFi.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
b = registerConnectivityBroadcast(2);
- mWiFiNetworkAgent.connect(false);
+ mWiFiAgent.connect(false);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_WIFI);
// Test WiFi disconnect.
b = registerConnectivityBroadcast(2);
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_CELLULAR);
// Test cellular disconnect.
b = registerConnectivityBroadcast(1);
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
b.expectBroadcast();
verifyNoNetwork();
}
@@ -2692,28 +2692,28 @@
final boolean cellRadioTimesharingCapable) throws Exception {
mService.mCellularRadioTimesharingCapable = cellRadioTimesharingCapable;
// Test bringing up unvalidated WiFi.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
ExpectedBroadcast b = registerConnectivityBroadcast(1);
- mWiFiNetworkAgent.connect(false);
+ mWiFiAgent.connect(false);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_WIFI);
- assertFalse(mCm.getNetworkCapabilities(mWiFiNetworkAgent.getNetwork()).hasCapability(
+ assertFalse(mCm.getNetworkCapabilities(mWiFiAgent.getNetwork()).hasCapability(
NET_CAPABILITY_VALIDATED));
// Test bringing up validated cellular.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
b = registerConnectivityBroadcast(2);
- mCellNetworkAgent.connect(true);
+ mCellAgent.connect(true);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_CELLULAR);
- assertFalse(mCm.getNetworkCapabilities(mWiFiNetworkAgent.getNetwork()).hasCapability(
+ assertFalse(mCm.getNetworkCapabilities(mWiFiAgent.getNetwork()).hasCapability(
NET_CAPABILITY_VALIDATED));
// Test cellular disconnect.
b = registerConnectivityBroadcast(2);
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_WIFI);
// Unlingering a network should not cause it to be marked as validated.
- assertFalse(mCm.getNetworkCapabilities(mWiFiNetworkAgent.getNetwork()).hasCapability(
+ assertFalse(mCm.getNetworkCapabilities(mWiFiAgent.getNetwork()).hasCapability(
NET_CAPABILITY_VALIDATED));
}
@@ -2847,25 +2847,25 @@
final boolean cellRadioTimesharingCapable) throws Exception {
mService.mCellularRadioTimesharingCapable = cellRadioTimesharingCapable;
// Test bringing up validated cellular.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
ExpectedBroadcast b = registerConnectivityBroadcast(1);
- mCellNetworkAgent.connect(true);
+ mCellAgent.connect(true);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_CELLULAR);
// Test bringing up validated WiFi.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
b = registerConnectivityBroadcast(2);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent.connect(true);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_WIFI);
// Test WiFi getting really weak.
b = registerConnectivityBroadcast(2);
- mWiFiNetworkAgent.adjustScore(-11);
+ mWiFiAgent.adjustScore(-11);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_CELLULAR);
// Test WiFi restoring signal strength.
b = registerConnectivityBroadcast(2);
- mWiFiNetworkAgent.adjustScore(11);
+ mWiFiAgent.adjustScore(11);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_WIFI);
}
@@ -2887,29 +2887,29 @@
mService.mCellularRadioTimesharingCapable = cellRadioTimesharingCapable;
// Test bringing up WiFi without NET_CAPABILITY_INTERNET.
// Expect it to be torn down immediately because it satisfies no requests.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connectWithoutInternet();
- mWiFiNetworkAgent.expectDisconnected();
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connectWithoutInternet();
+ mWiFiAgent.expectDisconnected();
// Test bringing up cellular without NET_CAPABILITY_INTERNET.
// Expect it to be torn down immediately because it satisfies no requests.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mCellNetworkAgent.connectWithoutInternet();
- mCellNetworkAgent.expectDisconnected();
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mCellAgent.connectWithoutInternet();
+ mCellAgent.expectDisconnected();
// Test bringing up validated WiFi.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
final ExpectedBroadcast b = expectConnectivityAction(TYPE_WIFI, DetailedState.CONNECTED);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent.connect(true);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_WIFI);
// Test bringing up unvalidated cellular.
// Expect it to be torn down because it could never be the highest scoring network
// satisfying the default request even if it validated.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(false);
- mCellNetworkAgent.expectDisconnected();
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(false);
+ mCellAgent.expectDisconnected();
verifyActiveNetwork(TRANSPORT_WIFI);
- mWiFiNetworkAgent.disconnect();
- mWiFiNetworkAgent.expectDisconnected();
+ mWiFiAgent.disconnect();
+ mWiFiAgent.expectDisconnected();
}
// TODO : migrate to @Parameterized
@@ -2928,37 +2928,37 @@
final boolean cellRadioTimesharingCapable) throws Exception {
mService.mCellularRadioTimesharingCapable = cellRadioTimesharingCapable;
// Test bringing up validated cellular.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
ExpectedBroadcast b = registerConnectivityBroadcast(1);
- mCellNetworkAgent.connect(true);
+ mCellAgent.connect(true);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_CELLULAR);
// Test bringing up validated WiFi.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
b = registerConnectivityBroadcast(2);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent.connect(true);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_WIFI);
// Reevaluate WiFi (it'll instantly fail DNS).
b = registerConnectivityBroadcast(2);
- assertTrue(mCm.getNetworkCapabilities(mWiFiNetworkAgent.getNetwork()).hasCapability(
+ assertTrue(mCm.getNetworkCapabilities(mWiFiAgent.getNetwork()).hasCapability(
NET_CAPABILITY_VALIDATED));
- mCm.reportBadNetwork(mWiFiNetworkAgent.getNetwork());
+ mCm.reportBadNetwork(mWiFiAgent.getNetwork());
// Should quickly fall back to Cellular.
b.expectBroadcast();
- assertFalse(mCm.getNetworkCapabilities(mWiFiNetworkAgent.getNetwork()).hasCapability(
+ assertFalse(mCm.getNetworkCapabilities(mWiFiAgent.getNetwork()).hasCapability(
NET_CAPABILITY_VALIDATED));
verifyActiveNetwork(TRANSPORT_CELLULAR);
// Reevaluate cellular (it'll instantly fail DNS).
b = registerConnectivityBroadcast(2);
- assertTrue(mCm.getNetworkCapabilities(mCellNetworkAgent.getNetwork()).hasCapability(
+ assertTrue(mCm.getNetworkCapabilities(mCellAgent.getNetwork()).hasCapability(
NET_CAPABILITY_VALIDATED));
- mCm.reportBadNetwork(mCellNetworkAgent.getNetwork());
+ mCm.reportBadNetwork(mCellAgent.getNetwork());
// Should quickly fall back to WiFi.
b.expectBroadcast();
- assertFalse(mCm.getNetworkCapabilities(mCellNetworkAgent.getNetwork()).hasCapability(
+ assertFalse(mCm.getNetworkCapabilities(mCellAgent.getNetwork()).hasCapability(
NET_CAPABILITY_VALIDATED));
- assertFalse(mCm.getNetworkCapabilities(mWiFiNetworkAgent.getNetwork()).hasCapability(
+ assertFalse(mCm.getNetworkCapabilities(mWiFiAgent.getNetwork()).hasCapability(
NET_CAPABILITY_VALIDATED));
verifyActiveNetwork(TRANSPORT_WIFI);
}
@@ -2979,25 +2979,25 @@
final boolean cellRadioTimesharingCapable) throws Exception {
mService.mCellularRadioTimesharingCapable = cellRadioTimesharingCapable;
// Test bringing up unvalidated WiFi.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
ExpectedBroadcast b = registerConnectivityBroadcast(1);
- mWiFiNetworkAgent.connect(false);
+ mWiFiAgent.connect(false);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_WIFI);
// Test bringing up validated cellular.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
b = registerConnectivityBroadcast(2);
- mCellNetworkAgent.connect(true);
+ mCellAgent.connect(true);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_CELLULAR);
// Reevaluate cellular (it'll instantly fail DNS).
b = registerConnectivityBroadcast(2);
- assertTrue(mCm.getNetworkCapabilities(mCellNetworkAgent.getNetwork()).hasCapability(
+ assertTrue(mCm.getNetworkCapabilities(mCellAgent.getNetwork()).hasCapability(
NET_CAPABILITY_VALIDATED));
- mCm.reportBadNetwork(mCellNetworkAgent.getNetwork());
+ mCm.reportBadNetwork(mCellAgent.getNetwork());
// Should quickly fall back to WiFi.
b.expectBroadcast();
- assertFalse(mCm.getNetworkCapabilities(mCellNetworkAgent.getNetwork()).hasCapability(
+ assertFalse(mCm.getNetworkCapabilities(mCellAgent.getNetwork()).hasCapability(
NET_CAPABILITY_VALIDATED));
verifyActiveNetwork(TRANSPORT_WIFI);
}
@@ -3083,12 +3083,12 @@
final NetworkRequest wifiRequest = new NetworkRequest.Builder()
.addTransportType(TRANSPORT_WIFI).build();
mCm.requestNetwork(wifiRequest, cb);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
// Updating the score triggers a rematch.
- mWiFiNetworkAgent.setScore(new NetworkScore.Builder().build());
+ mWiFiAgent.setScore(new NetworkScore.Builder().build());
cb.assertNoCallback();
- mWiFiNetworkAgent.connect(false);
- cb.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mWiFiAgent.connect(false);
+ cb.expectAvailableCallbacksUnvalidated(mWiFiAgent);
cb.assertNoCallback();
mCm.unregisterNetworkCallback(cb);
}
@@ -3099,13 +3099,13 @@
final NetworkRequest wifiRequest = new NetworkRequest.Builder()
.addTransportType(TRANSPORT_WIFI).build();
mCm.registerNetworkCallback(wifiRequest, cb);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- final NetworkCapabilities nc = mWiFiNetworkAgent.getNetworkCapabilities();
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ final NetworkCapabilities nc = mWiFiAgent.getNetworkCapabilities();
nc.addCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED);
- mWiFiNetworkAgent.setNetworkCapabilities(nc, true /* sendToConnectivityService */);
+ mWiFiAgent.setNetworkCapabilities(nc, true /* sendToConnectivityService */);
cb.assertNoCallback();
- mWiFiNetworkAgent.connect(false);
- cb.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mWiFiAgent.connect(false);
+ cb.expectAvailableCallbacksUnvalidated(mWiFiAgent);
final CallbackEntry found = CollectionUtils.findLast(cb.getHistory(),
it -> it instanceof CallbackEntry.CapabilitiesChanged);
assertTrue(((CallbackEntry.CapabilitiesChanged) found).getCaps()
@@ -3131,79 +3131,79 @@
// Test unvalidated networks
ExpectedBroadcast b = registerConnectivityBroadcast(1);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(false);
- genericNetworkCallback.expectAvailableCallbacksUnvalidated(mCellNetworkAgent);
- cellNetworkCallback.expectAvailableCallbacksUnvalidated(mCellNetworkAgent);
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(false);
+ genericNetworkCallback.expectAvailableCallbacksUnvalidated(mCellAgent);
+ cellNetworkCallback.expectAvailableCallbacksUnvalidated(mCellAgent);
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
b.expectBroadcast();
assertNoCallbacks(genericNetworkCallback, wifiNetworkCallback, cellNetworkCallback);
// This should not trigger spurious onAvailable() callbacks, b/21762680.
- mCellNetworkAgent.adjustScore(-1);
+ mCellAgent.adjustScore(-1);
waitForIdle();
assertNoCallbacks(genericNetworkCallback, wifiNetworkCallback, cellNetworkCallback);
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
b = registerConnectivityBroadcast(2);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
- genericNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- wifiNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
+ genericNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ wifiNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
b.expectBroadcast();
assertNoCallbacks(genericNetworkCallback, wifiNetworkCallback, cellNetworkCallback);
b = registerConnectivityBroadcast(2);
- mWiFiNetworkAgent.disconnect();
- genericNetworkCallback.expect(LOST, mWiFiNetworkAgent);
- wifiNetworkCallback.expect(LOST, mWiFiNetworkAgent);
+ mWiFiAgent.disconnect();
+ genericNetworkCallback.expect(LOST, mWiFiAgent);
+ wifiNetworkCallback.expect(LOST, mWiFiAgent);
cellNetworkCallback.assertNoCallback();
b.expectBroadcast();
assertNoCallbacks(genericNetworkCallback, wifiNetworkCallback, cellNetworkCallback);
b = registerConnectivityBroadcast(1);
- mCellNetworkAgent.disconnect();
- genericNetworkCallback.expect(LOST, mCellNetworkAgent);
- cellNetworkCallback.expect(LOST, mCellNetworkAgent);
+ mCellAgent.disconnect();
+ genericNetworkCallback.expect(LOST, mCellAgent);
+ cellNetworkCallback.expect(LOST, mCellAgent);
b.expectBroadcast();
assertNoCallbacks(genericNetworkCallback, wifiNetworkCallback, cellNetworkCallback);
// Test validated networks
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- genericNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ genericNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
assertNoCallbacks(genericNetworkCallback, wifiNetworkCallback, cellNetworkCallback);
// This should not trigger spurious onAvailable() callbacks, b/21762680.
- mCellNetworkAgent.adjustScore(-1);
+ mCellAgent.adjustScore(-1);
waitForIdle();
assertNoCallbacks(genericNetworkCallback, wifiNetworkCallback, cellNetworkCallback);
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
- genericNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- genericNetworkCallback.expectLosing(mCellNetworkAgent);
- genericNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
- wifiNetworkCallback.expectAvailableThenValidatedCallbacks(mWiFiNetworkAgent);
- cellNetworkCallback.expectLosing(mCellNetworkAgent);
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
+ genericNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ genericNetworkCallback.expectLosing(mCellAgent);
+ genericNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ wifiNetworkCallback.expectAvailableThenValidatedCallbacks(mWiFiAgent);
+ cellNetworkCallback.expectLosing(mCellAgent);
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
// Cell will disconnect after the lingering period. Before that elapses check that
// there have been no callbacks.
assertNoCallbacks(0 /* timeoutMs */,
genericNetworkCallback, wifiNetworkCallback, cellNetworkCallback);
- mWiFiNetworkAgent.disconnect();
- genericNetworkCallback.expect(LOST, mWiFiNetworkAgent);
- wifiNetworkCallback.expect(LOST, mWiFiNetworkAgent);
+ mWiFiAgent.disconnect();
+ genericNetworkCallback.expect(LOST, mWiFiAgent);
+ wifiNetworkCallback.expect(LOST, mWiFiAgent);
assertNoCallbacks(genericNetworkCallback, wifiNetworkCallback, cellNetworkCallback);
- mCellNetworkAgent.disconnect();
- genericNetworkCallback.expect(LOST, mCellNetworkAgent);
- cellNetworkCallback.expect(LOST, mCellNetworkAgent);
+ mCellAgent.disconnect();
+ genericNetworkCallback.expect(LOST, mCellAgent);
+ cellNetworkCallback.expect(LOST, mCellAgent);
assertNoCallbacks(genericNetworkCallback, wifiNetworkCallback, cellNetworkCallback);
}
@@ -3215,10 +3215,10 @@
mCm.registerNetworkCallback(wifiRequest, callback);
mCm.registerDefaultNetworkCallback(defaultCallback);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- defaultCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ defaultCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
final LinkProperties newLp = new LinkProperties();
final Uri capportUrl = Uri.parse("https://capport.example.com/api");
@@ -3227,20 +3227,20 @@
final Uri expectedCapportUrl = sanitized ? null : capportUrl;
newLp.setCaptivePortalApiUrl(capportUrl);
- mWiFiNetworkAgent.sendLinkProperties(newLp);
- callback.expectLinkPropertiesThat(mWiFiNetworkAgent, lp ->
+ mWiFiAgent.sendLinkProperties(newLp);
+ callback.expectLinkPropertiesThat(mWiFiAgent, lp ->
Objects.equals(expectedCapportUrl, lp.getCaptivePortalApiUrl()));
- defaultCallback.expectLinkPropertiesThat(mWiFiNetworkAgent, lp ->
+ defaultCallback.expectLinkPropertiesThat(mWiFiAgent, lp ->
Objects.equals(expectedCapportUrl, lp.getCaptivePortalApiUrl()));
final CaptivePortalData expectedCapportData = sanitized ? null : capportData;
- mWiFiNetworkAgent.notifyCapportApiDataChanged(capportData);
- callback.expectLinkPropertiesThat(mWiFiNetworkAgent, lp ->
+ mWiFiAgent.notifyCapportApiDataChanged(capportData);
+ callback.expectLinkPropertiesThat(mWiFiAgent, lp ->
Objects.equals(expectedCapportData, lp.getCaptivePortalData()));
- defaultCallback.expectLinkPropertiesThat(mWiFiNetworkAgent, lp ->
+ defaultCallback.expectLinkPropertiesThat(mWiFiAgent, lp ->
Objects.equals(expectedCapportData, lp.getCaptivePortalData()));
- final LinkProperties lp = mCm.getLinkProperties(mWiFiNetworkAgent.getNetwork());
+ final LinkProperties lp = mCm.getLinkProperties(mWiFiAgent.getNetwork());
assertEquals(expectedCapportUrl, lp.getCaptivePortalApiUrl());
assertEquals(expectedCapportData, lp.getCaptivePortalData());
}
@@ -3275,19 +3275,18 @@
final int originalOwnerUid = Process.myUid();
ncTemplate.setOwnerUid(originalOwnerUid);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, new LinkProperties(),
- ncTemplate);
- mWiFiNetworkAgent.connect(false);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, new LinkProperties(), ncTemplate);
+ mWiFiAgent.connect(false);
waitForIdle();
- // Send ConnectivityService an update to the mWiFiNetworkAgent's capabilities that changes
+ // Send ConnectivityService an update to the mWiFiAgent's capabilities that changes
// the owner UID and an unrelated capability.
- NetworkCapabilities agentCapabilities = mWiFiNetworkAgent.getNetworkCapabilities();
+ NetworkCapabilities agentCapabilities = mWiFiAgent.getNetworkCapabilities();
assertEquals(originalOwnerUid, agentCapabilities.getOwnerUid());
agentCapabilities.setOwnerUid(42);
assertFalse(agentCapabilities.hasCapability(NET_CAPABILITY_NOT_CONGESTED));
agentCapabilities.addCapability(NET_CAPABILITY_NOT_CONGESTED);
- mWiFiNetworkAgent.setNetworkCapabilities(agentCapabilities, true);
+ mWiFiAgent.setNetworkCapabilities(agentCapabilities, true);
waitForIdle();
// Owner UIDs are not visible without location permission.
@@ -3295,7 +3294,7 @@
Manifest.permission.ACCESS_FINE_LOCATION);
// Check that the capability change has been applied but the owner UID is not modified.
- NetworkCapabilities nc = mCm.getNetworkCapabilities(mWiFiNetworkAgent.getNetwork());
+ NetworkCapabilities nc = mCm.getNetworkCapabilities(mWiFiAgent.getNetwork());
assertEquals(originalOwnerUid, nc.getOwnerUid());
assertTrue(nc.hasCapability(NET_CAPABILITY_NOT_CONGESTED));
}
@@ -3317,56 +3316,56 @@
TestNetworkCallback defaultCallback = new TestNetworkCallback();
mCm.registerDefaultNetworkCallback(defaultCallback);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mEthernetNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_ETHERNET);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mEthernetAgent = new TestNetworkAgentWrapper(TRANSPORT_ETHERNET);
- mCellNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
- mWiFiNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
- mEthernetNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
+ mCellAgent.addCapability(NET_CAPABILITY_NOT_METERED);
+ mWiFiAgent.addCapability(NET_CAPABILITY_NOT_METERED);
+ mEthernetAgent.addCapability(NET_CAPABILITY_NOT_METERED);
- mCellNetworkAgent.connect(true);
- callback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- defaultCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ mCellAgent.connect(true);
+ callback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ defaultCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent.connect(true);
// We get AVAILABLE on wifi when wifi connects and satisfies our unmetered request.
// We then get LOSING when wifi validates and cell is outscored.
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
// TODO: Investigate sending validated before losing.
- callback.expectLosing(mCellNetworkAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
- defaultCallback.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ callback.expectLosing(mCellAgent);
+ callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ defaultCallback.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
- mEthernetNetworkAgent.connect(true);
- callback.expectAvailableCallbacksUnvalidated(mEthernetNetworkAgent);
+ mEthernetAgent.connect(true);
+ callback.expectAvailableCallbacksUnvalidated(mEthernetAgent);
// TODO: Investigate sending validated before losing.
- callback.expectLosing(mWiFiNetworkAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mEthernetNetworkAgent);
- defaultCallback.expectAvailableDoubleValidatedCallbacks(mEthernetNetworkAgent);
- assertEquals(mEthernetNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ callback.expectLosing(mWiFiAgent);
+ callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mEthernetAgent);
+ defaultCallback.expectAvailableDoubleValidatedCallbacks(mEthernetAgent);
+ assertEquals(mEthernetAgent.getNetwork(), mCm.getActiveNetwork());
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
- mEthernetNetworkAgent.disconnect();
- callback.expect(LOST, mEthernetNetworkAgent);
- defaultCallback.expect(LOST, mEthernetNetworkAgent);
- defaultCallback.expectAvailableCallbacksValidated(mWiFiNetworkAgent);
+ mEthernetAgent.disconnect();
+ callback.expect(LOST, mEthernetAgent);
+ defaultCallback.expect(LOST, mEthernetAgent);
+ defaultCallback.expectAvailableCallbacksValidated(mWiFiAgent);
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
for (int i = 0; i < 4; i++) {
TestNetworkAgentWrapper oldNetwork, newNetwork;
if (i % 2 == 0) {
- mWiFiNetworkAgent.adjustScore(-15);
- oldNetwork = mWiFiNetworkAgent;
- newNetwork = mCellNetworkAgent;
+ mWiFiAgent.adjustScore(-15);
+ oldNetwork = mWiFiAgent;
+ newNetwork = mCellAgent;
} else {
- mWiFiNetworkAgent.adjustScore(15);
- oldNetwork = mCellNetworkAgent;
- newNetwork = mWiFiNetworkAgent;
+ mWiFiAgent.adjustScore(15);
+ oldNetwork = mCellAgent;
+ newNetwork = mWiFiAgent;
}
callback.expectLosing(oldNetwork);
@@ -3375,28 +3374,28 @@
defaultCallback.expectAvailableCallbacksValidated(newNetwork);
assertEquals(newNetwork.getNetwork(), mCm.getActiveNetwork());
}
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
// Verify that if a network no longer satisfies a request, we send LOST and not LOSING, even
// if the network is still up.
- mWiFiNetworkAgent.removeCapability(NET_CAPABILITY_NOT_METERED);
+ mWiFiAgent.removeCapability(NET_CAPABILITY_NOT_METERED);
// We expect a notification about the capabilities change, and nothing else.
- defaultCallback.expectCapabilitiesWithout(NET_CAPABILITY_NOT_METERED, mWiFiNetworkAgent);
+ defaultCallback.expectCapabilitiesWithout(NET_CAPABILITY_NOT_METERED, mWiFiAgent);
defaultCallback.assertNoCallback();
- callback.expect(LOST, mWiFiNetworkAgent);
+ callback.expect(LOST, mWiFiAgent);
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
// Wifi no longer satisfies our listen, which is for an unmetered network.
// But because its score is 55, it's still up (and the default network).
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
// Disconnect our test networks.
- mWiFiNetworkAgent.disconnect();
- defaultCallback.expect(LOST, mWiFiNetworkAgent);
- defaultCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ mWiFiAgent.disconnect();
+ defaultCallback.expect(LOST, mWiFiAgent);
+ defaultCallback.expectAvailableCallbacksValidated(mCellAgent);
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
- mCellNetworkAgent.disconnect();
- defaultCallback.expect(LOST, mCellNetworkAgent);
+ mCellAgent.disconnect();
+ defaultCallback.expect(LOST, mCellAgent);
waitForIdle();
assertEquals(null, mCm.getActiveNetwork());
@@ -3410,64 +3409,64 @@
mCm.registerNetworkCallback(request, callback);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(false); // Score: 10
- callback.expectAvailableCallbacksUnvalidated(mCellNetworkAgent);
- defaultCallback.expectAvailableCallbacksUnvalidated(mCellNetworkAgent);
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(false); // Score: 10
+ callback.expectAvailableCallbacksUnvalidated(mCellAgent);
+ defaultCallback.expectAvailableCallbacksUnvalidated(mCellAgent);
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
// Bring up wifi with a score of 20.
// Cell stays up because it would satisfy the default request if it validated.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false); // Score: 20
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- defaultCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false); // Score: 20
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ defaultCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
- mWiFiNetworkAgent.disconnect();
- callback.expect(LOST, mWiFiNetworkAgent);
- defaultCallback.expect(LOST, mWiFiNetworkAgent);
- defaultCallback.expectAvailableCallbacksUnvalidated(mCellNetworkAgent);
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ mWiFiAgent.disconnect();
+ callback.expect(LOST, mWiFiAgent);
+ defaultCallback.expect(LOST, mWiFiAgent);
+ defaultCallback.expectAvailableCallbacksUnvalidated(mCellAgent);
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
// Bring up wifi, then validate it. Previous versions would immediately tear down cell, but
// it's arguably correct to linger it, since it was the default network before it validated.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
// TODO: Investigate sending validated before losing.
- callback.expectLosing(mCellNetworkAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
- defaultCallback.expectAvailableThenValidatedCallbacks(mWiFiNetworkAgent);
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ callback.expectLosing(mCellAgent);
+ callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ defaultCallback.expectAvailableThenValidatedCallbacks(mWiFiAgent);
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
- mWiFiNetworkAgent.disconnect();
- callback.expect(LOST, mWiFiNetworkAgent);
- defaultCallback.expect(LOST, mWiFiNetworkAgent);
- defaultCallback.expectAvailableCallbacksUnvalidated(mCellNetworkAgent);
- mCellNetworkAgent.disconnect();
- callback.expect(LOST, mCellNetworkAgent);
- defaultCallback.expect(LOST, mCellNetworkAgent);
+ mWiFiAgent.disconnect();
+ callback.expect(LOST, mWiFiAgent);
+ defaultCallback.expect(LOST, mWiFiAgent);
+ defaultCallback.expectAvailableCallbacksUnvalidated(mCellAgent);
+ mCellAgent.disconnect();
+ callback.expect(LOST, mCellAgent);
+ defaultCallback.expect(LOST, mCellAgent);
waitForIdle();
assertEquals(null, mCm.getActiveNetwork());
// If a network is lingering, and we add and remove a request from it, resume lingering.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- callback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- defaultCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ callback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ defaultCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
- defaultCallback.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
+ defaultCallback.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
// TODO: Investigate sending validated before losing.
- callback.expectLosing(mCellNetworkAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
+ callback.expectLosing(mCellAgent);
+ callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
NetworkRequest cellRequest = new NetworkRequest.Builder()
@@ -3477,14 +3476,14 @@
// TODO: should this cause an AVAILABLE callback, to indicate that the network is no longer
// lingering?
mCm.unregisterNetworkCallback(noopCallback);
- callback.expectLosing(mCellNetworkAgent);
+ callback.expectLosing(mCellAgent);
// Similar to the above: lingering can start even after the lingered request is removed.
// Disconnect wifi and switch to cell.
- mWiFiNetworkAgent.disconnect();
- callback.expect(LOST, mWiFiNetworkAgent);
- defaultCallback.expect(LOST, mWiFiNetworkAgent);
- defaultCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ mWiFiAgent.disconnect();
+ callback.expect(LOST, mWiFiAgent);
+ defaultCallback.expect(LOST, mWiFiAgent);
+ defaultCallback.expectAvailableCallbacksValidated(mCellAgent);
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
// Cell is now the default network. Pin it with a cell-specific request.
@@ -3492,44 +3491,44 @@
mCm.requestNetwork(cellRequest, noopCallback);
// Now connect wifi, and expect it to become the default network.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
- callback.expectAvailableThenValidatedCallbacks(mWiFiNetworkAgent);
- defaultCallback.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
+ callback.expectAvailableThenValidatedCallbacks(mWiFiAgent);
+ defaultCallback.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
// The default request is lingering on cell, but nothing happens to cell, and we send no
// callbacks for it, because it's kept up by cellRequest.
callback.assertNoCallback();
// Now unregister cellRequest and expect cell to start lingering.
mCm.unregisterNetworkCallback(noopCallback);
- callback.expectLosing(mCellNetworkAgent);
+ callback.expectLosing(mCellAgent);
// Let linger run its course.
callback.assertNoCallback(0 /* timeoutMs */);
final int lingerTimeoutMs = mService.mLingerDelayMs + mService.mLingerDelayMs / 4;
- callback.expect(LOST, mCellNetworkAgent, lingerTimeoutMs);
+ callback.expect(LOST, mCellAgent, lingerTimeoutMs);
// Register a TRACK_DEFAULT request and check that it does not affect lingering.
TestNetworkCallback trackDefaultCallback = new TestNetworkCallback();
mCm.registerDefaultNetworkCallback(trackDefaultCallback);
- trackDefaultCallback.expectAvailableCallbacksValidated(mWiFiNetworkAgent);
- mEthernetNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_ETHERNET);
- mEthernetNetworkAgent.connect(true);
- callback.expectAvailableCallbacksUnvalidated(mEthernetNetworkAgent);
- callback.expectLosing(mWiFiNetworkAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mEthernetNetworkAgent);
- trackDefaultCallback.expectAvailableDoubleValidatedCallbacks(mEthernetNetworkAgent);
- defaultCallback.expectAvailableDoubleValidatedCallbacks(mEthernetNetworkAgent);
+ trackDefaultCallback.expectAvailableCallbacksValidated(mWiFiAgent);
+ mEthernetAgent = new TestNetworkAgentWrapper(TRANSPORT_ETHERNET);
+ mEthernetAgent.connect(true);
+ callback.expectAvailableCallbacksUnvalidated(mEthernetAgent);
+ callback.expectLosing(mWiFiAgent);
+ callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mEthernetAgent);
+ trackDefaultCallback.expectAvailableDoubleValidatedCallbacks(mEthernetAgent);
+ defaultCallback.expectAvailableDoubleValidatedCallbacks(mEthernetAgent);
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
// Let linger run its course.
- callback.expect(LOST, mWiFiNetworkAgent, lingerTimeoutMs);
+ callback.expect(LOST, mWiFiAgent, lingerTimeoutMs);
// Clean up.
- mEthernetNetworkAgent.disconnect();
- callback.expect(LOST, mEthernetNetworkAgent);
- defaultCallback.expect(LOST, mEthernetNetworkAgent);
- trackDefaultCallback.expect(LOST, mEthernetNetworkAgent);
+ mEthernetAgent.disconnect();
+ callback.expect(LOST, mEthernetAgent);
+ defaultCallback.expect(LOST, mEthernetAgent);
+ trackDefaultCallback.expect(LOST, mEthernetAgent);
mCm.unregisterNetworkCallback(callback);
mCm.unregisterNetworkCallback(defaultCallback);
@@ -3565,19 +3564,19 @@
TestNetworkCallback defaultCallback = new TestNetworkCallback();
mCm.registerDefaultNetworkCallback(defaultCallback);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mCellNetworkAgent.connect(true);
- callback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- defaultCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent.connect(true);
+ callback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ defaultCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
// Wifi comes up and cell lingers.
- mWiFiNetworkAgent.connect(true);
- defaultCallback.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- callback.expectLosing(mCellNetworkAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
+ mWiFiAgent.connect(true);
+ defaultCallback.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ callback.expectLosing(mCellAgent);
+ callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
// File a request for cellular, then release it.
NetworkRequest cellRequest = new NetworkRequest.Builder()
@@ -3585,13 +3584,12 @@
NetworkCallback noopCallback = new NetworkCallback();
mCm.requestNetwork(cellRequest, noopCallback);
mCm.unregisterNetworkCallback(noopCallback);
- callback.expectLosing(mCellNetworkAgent);
+ callback.expectLosing(mCellAgent);
// Let linger run its course.
callback.assertNoCallback();
final int lingerTimeoutMs = TEST_LINGER_DELAY_MS + TEST_LINGER_DELAY_MS / 4;
- callback.expectCapabilitiesWithout(NET_CAPABILITY_FOREGROUND, mCellNetworkAgent,
- lingerTimeoutMs);
+ callback.expectCapabilitiesWithout(NET_CAPABILITY_FOREGROUND, mCellAgent, lingerTimeoutMs);
// Clean up.
mCm.unregisterNetworkCallback(defaultCallback);
@@ -3717,7 +3715,7 @@
final NetworkAgentWrapper.Callbacks callbacks = new NetworkAgentWrapper.Callbacks(
onNetworkCreated, onNetworkUnwanted, onNetworkDisconnected);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, callbacks);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, callbacks);
// Connect a network, and file a request for it after it has come up, to ensure the nascent
// timer is cleared and the test does not have to wait for it. Filing the request after the
@@ -3725,13 +3723,13 @@
// nascent timer if the first request satisfied by the network was filed before the network
// connected.
// TODO: fix this bug, file the request before connecting, and remove the waitForIdle.
- mWiFiNetworkAgent.connectWithoutInternet();
+ mWiFiAgent.connectWithoutInternet();
waitForIdle();
mCm.requestNetwork(request, callback);
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
// Set teardown delay and make sure CS has processed it.
- mWiFiNetworkAgent.getNetworkAgent().setTeardownDelayMillis(300);
+ mWiFiAgent.getNetworkAgent().setTeardownDelayMillis(300);
waitForIdle();
// Post the duringTeardown lambda to the handler so it fires while teardown is in progress.
@@ -3739,7 +3737,7 @@
// down the network and started the teardown timer, and short enough that the lambda is
// scheduled to run before the teardown timer.
final Handler h = new Handler(mCsHandlerThread.getLooper());
- h.postDelayed(() -> duringTeardown.accept(mWiFiNetworkAgent.getNetwork()), 150);
+ h.postDelayed(() -> duringTeardown.accept(mWiFiAgent.getNetwork()), 150);
// Disconnect the network and check that events happened in the right order.
mCm.unregisterNetworkCallback(callback);
@@ -3760,106 +3758,104 @@
mCm.registerNetworkCallback(request, callback);
// Bring up validated cell.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- callback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ callback.expectAvailableThenValidatedCallbacks(mCellAgent);
// Bring up unvalidated wifi with explicitlySelected=true.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.explicitlySelected(true, false);
- mWiFiNetworkAgent.connect(false);
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.explicitlySelected(true, false);
+ mWiFiAgent.connect(false);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
// Cell remains the default.
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
// Expect a high-priority NO_INTERNET notification.
- expectUnvalidationCheckWillNotify(mWiFiNetworkAgent, NotificationType.NO_INTERNET);
+ expectUnvalidationCheckWillNotify(mWiFiAgent, NotificationType.NO_INTERNET);
// Lower WiFi's score to lower than cell, and check that it doesn't disconnect because
// it's explicitly selected.
- mWiFiNetworkAgent.adjustScore(-40);
- mWiFiNetworkAgent.adjustScore(40);
+ mWiFiAgent.adjustScore(-40);
+ mWiFiAgent.adjustScore(40);
callback.assertNoCallback();
// If the user chooses yes on the "No Internet access, stay connected?" dialog, we switch to
// wifi even though it's unvalidated.
- mCm.setAcceptUnvalidated(mWiFiNetworkAgent.getNetwork(), true, false);
- callback.expectLosing(mCellNetworkAgent);
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ mCm.setAcceptUnvalidated(mWiFiAgent.getNetwork(), true, false);
+ callback.expectLosing(mCellAgent);
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
// Disconnect wifi, and then reconnect, again with explicitlySelected=true.
- mWiFiNetworkAgent.disconnect();
- expectDisconnectAndClearNotifications(callback, mWiFiNetworkAgent,
- NotificationType.NO_INTERNET);
+ mWiFiAgent.disconnect();
+ expectDisconnectAndClearNotifications(callback, mWiFiAgent, NotificationType.NO_INTERNET);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.explicitlySelected(true, false);
- mWiFiNetworkAgent.connect(false);
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.explicitlySelected(true, false);
+ mWiFiAgent.connect(false);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
// Expect a high-priority NO_INTERNET notification.
- expectUnvalidationCheckWillNotify(mWiFiNetworkAgent, NotificationType.NO_INTERNET);
+ expectUnvalidationCheckWillNotify(mWiFiAgent, NotificationType.NO_INTERNET);
// If the user chooses no on the "No Internet access, stay connected?" dialog, we ask the
// network to disconnect.
- mCm.setAcceptUnvalidated(mWiFiNetworkAgent.getNetwork(), false, false);
- expectDisconnectAndClearNotifications(callback, mWiFiNetworkAgent,
- NotificationType.NO_INTERNET);
+ mCm.setAcceptUnvalidated(mWiFiAgent.getNetwork(), false, false);
+ expectDisconnectAndClearNotifications(callback, mWiFiAgent, NotificationType.NO_INTERNET);
reset(mNotificationManager);
// Reconnect, again with explicitlySelected=true, but this time validate.
// Expect no notifications.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.explicitlySelected(true, false);
- mWiFiNetworkAgent.connect(true);
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- callback.expectLosing(mCellNetworkAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
- expectUnvalidationCheckWillNotNotify(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.explicitlySelected(true, false);
+ mWiFiAgent.connect(true);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ callback.expectLosing(mCellAgent);
+ callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
+ expectUnvalidationCheckWillNotNotify(mWiFiAgent);
- mEthernetNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_ETHERNET);
- mEthernetNetworkAgent.connect(true);
- callback.expectAvailableCallbacksUnvalidated(mEthernetNetworkAgent);
- callback.expectLosing(mWiFiNetworkAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mEthernetNetworkAgent);
- assertEquals(mEthernetNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ mEthernetAgent = new TestNetworkAgentWrapper(TRANSPORT_ETHERNET);
+ mEthernetAgent.connect(true);
+ callback.expectAvailableCallbacksUnvalidated(mEthernetAgent);
+ callback.expectLosing(mWiFiAgent);
+ callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mEthernetAgent);
+ assertEquals(mEthernetAgent.getNetwork(), mCm.getActiveNetwork());
callback.assertNoCallback();
// Disconnect wifi, and then reconnect as if the user had selected "yes, don't ask again"
// (i.e., with explicitlySelected=true and acceptUnvalidated=true). Expect to switch to
// wifi immediately.
- mWiFiNetworkAgent.disconnect();
- callback.expect(LOST, mWiFiNetworkAgent);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.explicitlySelected(true, true);
- mWiFiNetworkAgent.connect(false);
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- callback.expectLosing(mEthernetNetworkAgent);
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
- mEthernetNetworkAgent.disconnect();
- callback.expect(LOST, mEthernetNetworkAgent);
- expectUnvalidationCheckWillNotNotify(mWiFiNetworkAgent);
+ mWiFiAgent.disconnect();
+ callback.expect(LOST, mWiFiAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.explicitlySelected(true, true);
+ mWiFiAgent.connect(false);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ callback.expectLosing(mEthernetAgent);
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
+ mEthernetAgent.disconnect();
+ callback.expect(LOST, mEthernetAgent);
+ expectUnvalidationCheckWillNotNotify(mWiFiAgent);
// Disconnect and reconnect with explicitlySelected=false and acceptUnvalidated=true.
// Check that the network is not scored specially and that the device prefers cell data.
- mWiFiNetworkAgent.disconnect();
- callback.expect(LOST, mWiFiNetworkAgent);
+ mWiFiAgent.disconnect();
+ callback.expect(LOST, mWiFiAgent);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.explicitlySelected(false, true);
- mWiFiNetworkAgent.connect(false);
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
- expectUnvalidationCheckWillNotNotify(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.explicitlySelected(false, true);
+ mWiFiAgent.connect(false);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
+ expectUnvalidationCheckWillNotNotify(mWiFiAgent);
// Clean up.
- mWiFiNetworkAgent.disconnect();
- mCellNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
+ mCellAgent.disconnect();
- callback.expect(LOST, mWiFiNetworkAgent);
- callback.expect(LOST, mCellNetworkAgent);
+ callback.expect(LOST, mWiFiAgent);
+ callback.expect(LOST, mCellAgent);
}
private void doTestFirstEvaluation(
@@ -3873,36 +3869,36 @@
TestNetworkCallback callback = new TestNetworkCallback();
mCm.registerNetworkCallback(request, callback);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- doConnect.accept(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ doConnect.accept(mWiFiAgent);
// Expect the available callbacks, but don't require specific values for their arguments
// since this method doesn't know how the network was connected.
- callback.expect(AVAILABLE, mWiFiNetworkAgent);
- callback.expect(NETWORK_CAPS_UPDATED, mWiFiNetworkAgent);
- callback.expect(LINK_PROPERTIES_CHANGED, mWiFiNetworkAgent);
- callback.expect(BLOCKED_STATUS, mWiFiNetworkAgent);
+ callback.expect(AVAILABLE, mWiFiAgent);
+ callback.expect(NETWORK_CAPS_UPDATED, mWiFiAgent);
+ callback.expect(LINK_PROPERTIES_CHANGED, mWiFiAgent);
+ callback.expect(BLOCKED_STATUS, mWiFiAgent);
if (waitForSecondCaps) {
// This is necessary because of b/245893397, the same bug that happens where we use
// expectAvailableDoubleValidatedCallbacks.
- callback.expect(NETWORK_CAPS_UPDATED, mWiFiNetworkAgent);
+ callback.expect(NETWORK_CAPS_UPDATED, mWiFiAgent);
}
final NetworkAgentInfo nai =
- mService.getNetworkAgentInfoForNetwork(mWiFiNetworkAgent.getNetwork());
+ mService.getNetworkAgentInfoForNetwork(mWiFiAgent.getNetwork());
final long firstEvaluation = nai.getFirstEvaluationConcludedTime();
if (evaluatedByValidation) {
assertNotEquals(0L, firstEvaluation);
} else {
assertEquals(0L, firstEvaluation);
}
- mService.scheduleEvaluationTimeout(mWiFiNetworkAgent.getNetwork(), 0L /* timeout */);
+ mService.scheduleEvaluationTimeout(mWiFiAgent.getNetwork(), 0L /* timeout */);
waitForIdle();
if (evaluatedByValidation) {
assertEquals(firstEvaluation, nai.getFirstEvaluationConcludedTime());
} else {
assertNotEquals(0L, nai.getFirstEvaluationConcludedTime());
}
- mWiFiNetworkAgent.disconnect();
- callback.expect(LOST, mWiFiNetworkAgent);
+ mWiFiAgent.disconnect();
+ callback.expect(LOST, mWiFiAgent);
mCm.unregisterNetworkCallback(callback);
}
@@ -4071,9 +4067,9 @@
@Test
public void testRegisterIgnoringScore() throws Exception {
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.setScore(new NetworkScore.Builder().setLegacyInt(90).build());
- mWiFiNetworkAgent.connect(true /* validated */);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.setScore(new NetworkScore.Builder().setLegacyInt(90).build());
+ mWiFiAgent.connect(true /* validated */);
// Make sure the factory sees the default network
final NetworkCapabilities filter = new NetworkCapabilities();
@@ -4096,13 +4092,13 @@
testFactoryAll.expectRequestAdd();
// The legacy int will be ignored anyway, set the only other knob to true
- mWiFiNetworkAgent.setScore(new NetworkScore.Builder().setLegacyInt(110)
+ mWiFiAgent.setScore(new NetworkScore.Builder().setLegacyInt(110)
.setTransportPrimary(true).build());
expectNoRequestChanged(testFactory); // still not seeing the request
expectNoRequestChanged(testFactoryAll); // still seeing the request
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
}
@Test
@@ -4190,18 +4186,18 @@
@Test
public void testMMSonWiFi() throws Exception {
// Test bringing up cellular without MMS NetworkRequest gets reaped
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.addCapability(NET_CAPABILITY_MMS);
- mCellNetworkAgent.connectWithoutInternet();
- mCellNetworkAgent.expectDisconnected();
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.addCapability(NET_CAPABILITY_MMS);
+ mCellAgent.connectWithoutInternet();
+ mCellAgent.expectDisconnected();
waitForIdle();
assertEmpty(mCm.getAllNetworks());
verifyNoNetwork();
// Test bringing up validated WiFi.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
final ExpectedBroadcast b = expectConnectivityAction(TYPE_WIFI, DetailedState.CONNECTED);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent.connect(true);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_WIFI);
@@ -4212,24 +4208,24 @@
mCm.requestNetwork(builder.build(), networkCallback);
// Test bringing up unvalidated cellular with MMS
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.addCapability(NET_CAPABILITY_MMS);
- mCellNetworkAgent.connectWithoutInternet();
- networkCallback.expectAvailableCallbacksUnvalidated(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.addCapability(NET_CAPABILITY_MMS);
+ mCellAgent.connectWithoutInternet();
+ networkCallback.expectAvailableCallbacksUnvalidated(mCellAgent);
verifyActiveNetwork(TRANSPORT_WIFI);
// Test releasing NetworkRequest disconnects cellular with MMS
mCm.unregisterNetworkCallback(networkCallback);
- mCellNetworkAgent.expectDisconnected();
+ mCellAgent.expectDisconnected();
verifyActiveNetwork(TRANSPORT_WIFI);
}
@Test
public void testMMSonCell() throws Exception {
// Test bringing up cellular without MMS
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
ExpectedBroadcast b = expectConnectivityAction(TYPE_MOBILE, DetailedState.CONNECTED);
- mCellNetworkAgent.connect(false);
+ mCellAgent.connect(false);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_CELLULAR);
@@ -4263,143 +4259,139 @@
mCm.registerNetworkCallback(request, callback);
// Bring up validated mobile data.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- callback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ callback.expectAvailableThenValidatedCallbacks(mCellAgent);
// Bring up wifi with partial connectivity.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connectWithPartialConnectivity();
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_PARTIAL_CONNECTIVITY, mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connectWithPartialConnectivity();
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ callback.expectCapabilitiesWith(NET_CAPABILITY_PARTIAL_CONNECTIVITY, mWiFiAgent);
// Mobile data should be the default network.
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
callback.assertNoCallback();
// Expect a PARTIAL_CONNECTIVITY notification. The notification appears as soon as partial
// connectivity is detected, and is low priority because the network was not explicitly
// selected by the user. This happens if we reconnect to a network where the user previously
// accepted partial connectivity without checking "always".
- expectNotification(mWiFiNetworkAgent, NotificationType.PARTIAL_CONNECTIVITY);
+ expectNotification(mWiFiAgent, NotificationType.PARTIAL_CONNECTIVITY);
// With HTTPS probe disabled, NetworkMonitor should pass the network validation with http
// probe.
- mWiFiNetworkAgent.setNetworkPartialValid(false /* privateDnsProbeSent */);
+ mWiFiAgent.setNetworkPartialValid(false /* privateDnsProbeSent */);
// If the user chooses yes to use this partial connectivity wifi, switch the default
// network to wifi and check if wifi becomes valid or not.
- mCm.setAcceptPartialConnectivity(mWiFiNetworkAgent.getNetwork(), true /* accept */,
+ mCm.setAcceptPartialConnectivity(mWiFiAgent.getNetwork(), true /* accept */,
false /* always */);
// If user accepts partial connectivity network,
// NetworkMonitor#setAcceptPartialConnectivity() should be called too.
waitForIdle();
- verify(mWiFiNetworkAgent.mNetworkMonitor, times(1)).setAcceptPartialConnectivity();
+ verify(mWiFiAgent.mNetworkMonitor, times(1)).setAcceptPartialConnectivity();
// Need a trigger point to let NetworkMonitor tell ConnectivityService that the network is
// validated.
- mCm.reportNetworkConnectivity(mWiFiNetworkAgent.getNetwork(), true);
- callback.expectLosing(mCellNetworkAgent);
+ mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), true);
+ callback.expectLosing(mCellAgent);
NetworkCapabilities nc = callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED,
- mWiFiNetworkAgent);
+ mWiFiAgent);
assertTrue(nc.hasCapability(NET_CAPABILITY_PARTIAL_CONNECTIVITY));
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
// Once the network validates, the notification disappears.
- expectClearNotification(mWiFiNetworkAgent, NotificationType.PARTIAL_CONNECTIVITY);
+ expectClearNotification(mWiFiAgent, NotificationType.PARTIAL_CONNECTIVITY);
// Disconnect and reconnect wifi with partial connectivity again.
- mWiFiNetworkAgent.disconnect();
- callback.expect(LOST, mWiFiNetworkAgent);
+ mWiFiAgent.disconnect();
+ callback.expect(LOST, mWiFiAgent);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connectWithPartialConnectivity();
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_PARTIAL_CONNECTIVITY, mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connectWithPartialConnectivity();
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ callback.expectCapabilitiesWith(NET_CAPABILITY_PARTIAL_CONNECTIVITY, mWiFiAgent);
// Mobile data should be the default network.
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
waitForIdle();
// Expect a low-priority PARTIAL_CONNECTIVITY notification as soon as partial connectivity
// is detected.
- expectNotification(mWiFiNetworkAgent, NotificationType.PARTIAL_CONNECTIVITY);
+ expectNotification(mWiFiAgent, NotificationType.PARTIAL_CONNECTIVITY);
// If the user chooses no, disconnect wifi immediately.
- mCm.setAcceptPartialConnectivity(mWiFiNetworkAgent.getNetwork(), false /* accept */,
+ mCm.setAcceptPartialConnectivity(mWiFiAgent.getNetwork(), false /* accept */,
false /* always */);
- callback.expect(LOST, mWiFiNetworkAgent);
- expectClearNotification(mWiFiNetworkAgent, NotificationType.PARTIAL_CONNECTIVITY);
+ callback.expect(LOST, mWiFiAgent);
+ expectClearNotification(mWiFiAgent, NotificationType.PARTIAL_CONNECTIVITY);
reset(mNotificationManager);
// If the user accepted partial connectivity before, and the device connects to that network
// again, but now the network has full connectivity, then the network shouldn't contain
// NET_CAPABILITY_PARTIAL_CONNECTIVITY.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
// acceptUnvalidated is also used as setting for accepting partial networks.
- mWiFiNetworkAgent.explicitlySelected(true /* explicitlySelected */,
- true /* acceptUnvalidated */);
- mWiFiNetworkAgent.connect(true);
- expectUnvalidationCheckWillNotNotify(mWiFiNetworkAgent);
+ mWiFiAgent.explicitlySelected(true /* explicitlySelected */, true /* acceptUnvalidated */);
+ mWiFiAgent.connect(true);
+ expectUnvalidationCheckWillNotNotify(mWiFiAgent);
// If user accepted partial connectivity network before,
// NetworkMonitor#setAcceptPartialConnectivity() will be called in
// ConnectivityService#updateNetworkInfo().
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- verify(mWiFiNetworkAgent.mNetworkMonitor, times(1)).setAcceptPartialConnectivity();
- callback.expectLosing(mCellNetworkAgent);
- nc = callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ verify(mWiFiAgent.mNetworkMonitor, times(1)).setAcceptPartialConnectivity();
+ callback.expectLosing(mCellAgent);
+ nc = callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
assertFalse(nc.hasCapability(NET_CAPABILITY_PARTIAL_CONNECTIVITY));
// Wifi should be the default network.
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
- mWiFiNetworkAgent.disconnect();
- callback.expect(LOST, mWiFiNetworkAgent);
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
+ mWiFiAgent.disconnect();
+ callback.expect(LOST, mWiFiAgent);
// The user accepted partial connectivity and selected "don't ask again". Now the user
// reconnects to the partial connectivity network. Switch to wifi as soon as partial
// connectivity is detected.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.explicitlySelected(true /* explicitlySelected */,
- true /* acceptUnvalidated */);
- mWiFiNetworkAgent.connectWithPartialConnectivity();
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.explicitlySelected(true /* explicitlySelected */, true /* acceptUnvalidated */);
+ mWiFiAgent.connectWithPartialConnectivity();
// If user accepted partial connectivity network before,
// NetworkMonitor#setAcceptPartialConnectivity() will be called in
// ConnectivityService#updateNetworkInfo().
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- verify(mWiFiNetworkAgent.mNetworkMonitor, times(1)).setAcceptPartialConnectivity();
- callback.expectLosing(mCellNetworkAgent);
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
- callback.expectCapabilitiesWith(NET_CAPABILITY_PARTIAL_CONNECTIVITY, mWiFiNetworkAgent);
- expectUnvalidationCheckWillNotNotify(mWiFiNetworkAgent);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ verify(mWiFiAgent.mNetworkMonitor, times(1)).setAcceptPartialConnectivity();
+ callback.expectLosing(mCellAgent);
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
+ callback.expectCapabilitiesWith(NET_CAPABILITY_PARTIAL_CONNECTIVITY, mWiFiAgent);
+ expectUnvalidationCheckWillNotNotify(mWiFiAgent);
- mWiFiNetworkAgent.setNetworkValid(false /* privateDnsProbeSent */);
+ mWiFiAgent.setNetworkValid(false /* privateDnsProbeSent */);
// Need a trigger point to let NetworkMonitor tell ConnectivityService that the network is
// validated.
- mCm.reportNetworkConnectivity(mWiFiNetworkAgent.getNetwork(), true);
- callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
- mWiFiNetworkAgent.disconnect();
- callback.expect(LOST, mWiFiNetworkAgent);
+ mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), true);
+ callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ mWiFiAgent.disconnect();
+ callback.expect(LOST, mWiFiAgent);
// If the user accepted partial connectivity, and the device auto-reconnects to the partial
// connectivity network, it should contain both PARTIAL_CONNECTIVITY and VALIDATED.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.explicitlySelected(false /* explicitlySelected */,
- true /* acceptUnvalidated */);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.explicitlySelected(false /* explicitlySelected */, true /* acceptUnvalidated */);
// NetworkMonitor will immediately (once the HTTPS probe fails...) report the network as
// valid, because ConnectivityService calls setAcceptPartialConnectivity before it calls
// notifyNetworkConnected.
- mWiFiNetworkAgent.connectWithPartialValidConnectivity(
- false /* privateDnsProbeSent */);
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- verify(mWiFiNetworkAgent.mNetworkMonitor, times(1)).setAcceptPartialConnectivity();
- callback.expectLosing(mCellNetworkAgent);
+ mWiFiAgent.connectWithPartialValidConnectivity(false /* privateDnsProbeSent */);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ verify(mWiFiAgent.mNetworkMonitor, times(1)).setAcceptPartialConnectivity();
+ callback.expectLosing(mCellAgent);
callback.expectCapabilitiesWith(
- NET_CAPABILITY_PARTIAL_CONNECTIVITY | NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
- expectUnvalidationCheckWillNotNotify(mWiFiNetworkAgent);
- mWiFiNetworkAgent.disconnect();
- callback.expect(LOST, mWiFiNetworkAgent);
+ NET_CAPABILITY_PARTIAL_CONNECTIVITY | NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ expectUnvalidationCheckWillNotNotify(mWiFiAgent);
+ mWiFiAgent.disconnect();
+ callback.expect(LOST, mWiFiAgent);
verifyNoMoreInteractions(mNotificationManager);
}
@@ -4418,43 +4410,39 @@
// Bring up a network with a captive portal.
// Expect onAvailable callback of listen for NET_CAPABILITY_CAPTIVE_PORTAL.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
String redirectUrl = "http://android.com/path";
- mWiFiNetworkAgent.connectWithCaptivePortal(redirectUrl,
- false /* privateDnsProbeSent */);
- wifiCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- assertEquals(mWiFiNetworkAgent.waitForRedirectUrl(), redirectUrl);
+ mWiFiAgent.connectWithCaptivePortal(redirectUrl, false /* privateDnsProbeSent */);
+ wifiCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ assertEquals(mWiFiAgent.waitForRedirectUrl(), redirectUrl);
// This is necessary because of b/245893397, the same bug that happens where we use
// expectAvailableDoubleValidatedCallbacks.
// TODO : fix b/245893397 and remove this.
- wifiCallback.expectCapabilitiesWith(NET_CAPABILITY_CAPTIVE_PORTAL, mWiFiNetworkAgent);
+ wifiCallback.expectCapabilitiesWith(NET_CAPABILITY_CAPTIVE_PORTAL, mWiFiAgent);
// Check that startCaptivePortalApp sends the expected command to NetworkMonitor.
- mCm.startCaptivePortalApp(mWiFiNetworkAgent.getNetwork());
- verify(mWiFiNetworkAgent.mNetworkMonitor, timeout(TIMEOUT_MS).times(1))
- .launchCaptivePortalApp();
+ mCm.startCaptivePortalApp(mWiFiAgent.getNetwork());
+ verify(mWiFiAgent.mNetworkMonitor, timeout(TIMEOUT_MS).times(1)).launchCaptivePortalApp();
// Report that the captive portal is dismissed with partial connectivity, and check that
// callbacks are fired with PARTIAL and without CAPTIVE_PORTAL.
- mWiFiNetworkAgent.setNetworkPartial();
- mCm.reportNetworkConnectivity(mWiFiNetworkAgent.getNetwork(), true);
+ mWiFiAgent.setNetworkPartial();
+ mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), true);
waitForIdle();
- wifiCallback.expectCapabilitiesThat(
- mWiFiNetworkAgent, nc ->
+ wifiCallback.expectCapabilitiesThat(mWiFiAgent, nc ->
nc.hasCapability(NET_CAPABILITY_PARTIAL_CONNECTIVITY)
- && !nc.hasCapability(NET_CAPABILITY_CAPTIVE_PORTAL));
+ && !nc.hasCapability(NET_CAPABILITY_CAPTIVE_PORTAL));
// Report partial connectivity is accepted.
- mWiFiNetworkAgent.setNetworkPartialValid(false /* privateDnsProbeSent */);
- mCm.setAcceptPartialConnectivity(mWiFiNetworkAgent.getNetwork(), true /* accept */,
+ mWiFiAgent.setNetworkPartialValid(false /* privateDnsProbeSent */);
+ mCm.setAcceptPartialConnectivity(mWiFiAgent.getNetwork(), true /* accept */,
false /* always */);
waitForIdle();
- mCm.reportNetworkConnectivity(mWiFiNetworkAgent.getNetwork(), true);
- wifiCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
- validatedCallback.expectAvailableCallbacksValidated(mWiFiNetworkAgent);
- validatedCallback.expectCapabilitiesWith(NET_CAPABILITY_PARTIAL_CONNECTIVITY,
- mWiFiNetworkAgent);
+ mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), true);
+ wifiCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ validatedCallback.expectAvailableCallbacksValidated(mWiFiAgent);
+ validatedCallback.expectCapabilitiesWith(NET_CAPABILITY_PARTIAL_CONNECTIVITY, mWiFiAgent);
mCm.unregisterNetworkCallback(wifiCallback);
mCm.unregisterNetworkCallback(validatedCallback);
@@ -4474,41 +4462,39 @@
// Bring up a network with a captive portal.
// Expect onAvailable callback of listen for NET_CAPABILITY_CAPTIVE_PORTAL.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
String firstRedirectUrl = "http://example.com/firstPath";
- mWiFiNetworkAgent.connectWithCaptivePortal(firstRedirectUrl,
- false /* privateDnsProbeSent */);
- captivePortalCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- assertEquals(mWiFiNetworkAgent.waitForRedirectUrl(), firstRedirectUrl);
+ mWiFiAgent.connectWithCaptivePortal(firstRedirectUrl, false /* privateDnsProbeSent */);
+ captivePortalCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ assertEquals(mWiFiAgent.waitForRedirectUrl(), firstRedirectUrl);
// Take down network.
// Expect onLost callback.
- mWiFiNetworkAgent.disconnect();
- captivePortalCallback.expect(LOST, mWiFiNetworkAgent);
+ mWiFiAgent.disconnect();
+ captivePortalCallback.expect(LOST, mWiFiAgent);
// Bring up a network with a captive portal.
// Expect onAvailable callback of listen for NET_CAPABILITY_CAPTIVE_PORTAL.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
String secondRedirectUrl = "http://example.com/secondPath";
- mWiFiNetworkAgent.connectWithCaptivePortal(secondRedirectUrl,
- false /* privateDnsProbeSent */);
- captivePortalCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- assertEquals(mWiFiNetworkAgent.waitForRedirectUrl(), secondRedirectUrl);
+ mWiFiAgent.connectWithCaptivePortal(secondRedirectUrl, false /* privateDnsProbeSent */);
+ captivePortalCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ assertEquals(mWiFiAgent.waitForRedirectUrl(), secondRedirectUrl);
// Make captive portal disappear then revalidate.
// Expect onLost callback because network no longer provides NET_CAPABILITY_CAPTIVE_PORTAL.
- mWiFiNetworkAgent.setNetworkValid(false /* privateDnsProbeSent */);
- mCm.reportNetworkConnectivity(mWiFiNetworkAgent.getNetwork(), true);
- captivePortalCallback.expect(LOST, mWiFiNetworkAgent);
+ mWiFiAgent.setNetworkValid(false /* privateDnsProbeSent */);
+ mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), true);
+ captivePortalCallback.expect(LOST, mWiFiAgent);
// Expect NET_CAPABILITY_VALIDATED onAvailable callback.
- validatedCallback.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
+ validatedCallback.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
// Break network connectivity.
// Expect NET_CAPABILITY_VALIDATED onLost callback.
- mWiFiNetworkAgent.setNetworkInvalid(false /* invalidBecauseOfPrivateDns */);
- mCm.reportNetworkConnectivity(mWiFiNetworkAgent.getNetwork(), false);
- validatedCallback.expect(LOST, mWiFiNetworkAgent);
+ mWiFiAgent.setNetworkInvalid(false /* invalidBecauseOfPrivateDns */);
+ mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), false);
+ validatedCallback.expect(LOST, mWiFiAgent);
}
private Intent startCaptivePortalApp(TestNetworkAgentWrapper networkAgent) throws Exception {
@@ -4545,36 +4531,35 @@
mCm.registerNetworkCallback(validatedRequest, validatedCallback);
// Bring up wifi.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
- validatedCallback.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
- Network wifiNetwork = mWiFiNetworkAgent.getNetwork();
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
+ validatedCallback.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
+ Network wifiNetwork = mWiFiAgent.getNetwork();
// Check that calling startCaptivePortalApp does nothing.
final int fastTimeoutMs = 100;
mCm.startCaptivePortalApp(wifiNetwork);
waitForIdle();
- verify(mWiFiNetworkAgent.mNetworkMonitor, never()).launchCaptivePortalApp();
+ verify(mWiFiAgent.mNetworkMonitor, never()).launchCaptivePortalApp();
mServiceContext.expectNoStartActivityIntent(fastTimeoutMs);
// Turn into a captive portal.
- mWiFiNetworkAgent.setNetworkPortal("http://example.com",
- false /* privateDnsProbeSent */);
+ mWiFiAgent.setNetworkPortal("http://example.com", false /* privateDnsProbeSent */);
mCm.reportNetworkConnectivity(wifiNetwork, false);
- captivePortalCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- validatedCallback.expect(LOST, mWiFiNetworkAgent);
+ captivePortalCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ validatedCallback.expect(LOST, mWiFiAgent);
// This is necessary because of b/245893397, the same bug that happens where we use
// expectAvailableDoubleValidatedCallbacks.
// TODO : fix b/245893397 and remove this.
- captivePortalCallback.expect(NETWORK_CAPS_UPDATED, mWiFiNetworkAgent);
+ captivePortalCallback.expect(NETWORK_CAPS_UPDATED, mWiFiAgent);
- startCaptivePortalApp(mWiFiNetworkAgent);
+ startCaptivePortalApp(mWiFiAgent);
// Report that the captive portal is dismissed, and check that callbacks are fired
- mWiFiNetworkAgent.setNetworkValid(false /* privateDnsProbeSent */);
- mWiFiNetworkAgent.mNetworkMonitor.forceReevaluation(Process.myUid());
- validatedCallback.expectAvailableCallbacksValidated(mWiFiNetworkAgent);
- captivePortalCallback.expect(LOST, mWiFiNetworkAgent);
+ mWiFiAgent.setNetworkValid(false /* privateDnsProbeSent */);
+ mWiFiAgent.mNetworkMonitor.forceReevaluation(Process.myUid());
+ validatedCallback.expectAvailableCallbacksValidated(mWiFiAgent);
+ captivePortalCallback.expect(LOST, mWiFiAgent);
mCm.unregisterNetworkCallback(validatedCallback);
mCm.unregisterNetworkCallback(captivePortalCallback);
@@ -4587,11 +4572,11 @@
.addCapability(NET_CAPABILITY_CAPTIVE_PORTAL).build();
mCm.registerNetworkCallback(captivePortalRequest, captivePortalCallback);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connectWithCaptivePortal(TEST_REDIRECT_URL, false);
- captivePortalCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connectWithCaptivePortal(TEST_REDIRECT_URL, false);
+ captivePortalCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
- final Intent signInIntent = startCaptivePortalApp(mWiFiNetworkAgent);
+ final Intent signInIntent = startCaptivePortalApp(mWiFiAgent);
final CaptivePortal captivePortal = signInIntent
.getParcelableExtra(ConnectivityManager.EXTRA_CAPTIVE_PORTAL);
@@ -4599,14 +4584,14 @@
waitForIdle();
// Since network will disconnect, ensure no notification of response to NetworkMonitor
- verify(mWiFiNetworkAgent.mNetworkMonitor, never())
+ verify(mWiFiAgent.mNetworkMonitor, never())
.notifyCaptivePortalAppFinished(CaptivePortal.APP_RETURN_UNWANTED);
// Report that the network is disconnected
- mWiFiNetworkAgent.expectDisconnected();
- mWiFiNetworkAgent.expectPreventReconnectReceived();
- verify(mWiFiNetworkAgent.mNetworkMonitor).notifyNetworkDisconnected();
- captivePortalCallback.expect(LOST, mWiFiNetworkAgent);
+ mWiFiAgent.expectDisconnected();
+ mWiFiAgent.expectPreventReconnectReceived();
+ verify(mWiFiAgent.mNetworkMonitor).notifyNetworkDisconnected();
+ captivePortalCallback.expect(LOST, mWiFiAgent);
mCm.unregisterNetworkCallback(captivePortalCallback);
}
@@ -4626,13 +4611,12 @@
setCaptivePortalMode(ConnectivitySettingsManager.CAPTIVE_PORTAL_MODE_AVOID);
// Bring up a network with a captive portal.
// Expect it to fail to connect and not result in any callbacks.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- String firstRedirectUrl = "http://example.com/firstPath";
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ final String firstRedirectUrl = "http://example.com/firstPath";
- mWiFiNetworkAgent.connectWithCaptivePortal(firstRedirectUrl,
- false /* privateDnsProbeSent */);
- mWiFiNetworkAgent.expectDisconnected();
- mWiFiNetworkAgent.expectPreventReconnectReceived();
+ mWiFiAgent.connectWithCaptivePortal(firstRedirectUrl, false /* privateDnsProbeSent */);
+ mWiFiAgent.expectDisconnected();
+ mWiFiAgent.expectPreventReconnectReceived();
assertNoCallbacks(captivePortalCallback, validatedCallback);
}
@@ -4646,28 +4630,28 @@
.addCapability(NET_CAPABILITY_CAPTIVE_PORTAL).build();
mCm.registerNetworkCallback(captivePortalRequest, captivePortalCallback);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
final String redirectUrl = "http://example.com/firstPath";
- mWiFiNetworkAgent.connectWithCaptivePortal(redirectUrl,
+ mWiFiAgent.connectWithCaptivePortal(redirectUrl,
false /* privateDnsProbeSent */);
- captivePortalCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ captivePortalCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
final CaptivePortalData testData = new CaptivePortalData.Builder()
.setUserPortalUrl(Uri.parse(redirectUrl))
.setBytesRemaining(12345L)
.build();
- mWiFiNetworkAgent.notifyCapportApiDataChanged(testData);
+ mWiFiAgent.notifyCapportApiDataChanged(testData);
- captivePortalCallback.expectLinkPropertiesThat(mWiFiNetworkAgent,
+ captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
lp -> testData.equals(lp.getCaptivePortalData()));
final LinkProperties newLps = new LinkProperties();
newLps.setMtu(1234);
- mWiFiNetworkAgent.sendLinkProperties(newLps);
+ mWiFiAgent.sendLinkProperties(newLps);
// CaptivePortalData is not lost and unchanged when LPs are received from the NetworkAgent
- captivePortalCallback.expectLinkPropertiesThat(mWiFiNetworkAgent,
+ captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
lp -> testData.equals(lp.getCaptivePortalData()) && lp.getMtu() == 1234);
}
@@ -4681,11 +4665,11 @@
.addCapability(NET_CAPABILITY_CAPTIVE_PORTAL).build();
mCm.registerNetworkCallback(captivePortalRequest, captivePortalCallback);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connectWithCaptivePortal(TEST_REDIRECT_URL,
+ mWiFiAgent.connectWithCaptivePortal(TEST_REDIRECT_URL,
false /* privateDnsProbeSent */);
- captivePortalCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ captivePortalCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
return captivePortalCallback;
}
@@ -4760,52 +4744,52 @@
final CaptivePortalTestData captivePortalTestData = setupCaptivePortalData();
// Baseline capport data
- mWiFiNetworkAgent.notifyCapportApiDataChanged(captivePortalTestData.mCapportData);
+ mWiFiAgent.notifyCapportApiDataChanged(captivePortalTestData.mCapportData);
- captivePortalCallback.expectLinkPropertiesThat(mWiFiNetworkAgent,
+ captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
lp -> captivePortalTestData.mCapportData.equals(lp.getCaptivePortalData()));
// Venue URL, T&C URL and friendly name from Network agent with Passpoint source, confirm
// that API data gets precedence on the bytes remaining.
final LinkProperties linkProperties = new LinkProperties();
linkProperties.setCaptivePortalData(captivePortalTestData.mNaPasspointData);
- mWiFiNetworkAgent.sendLinkProperties(linkProperties);
+ mWiFiAgent.sendLinkProperties(linkProperties);
// Make sure that the capport data is merged
- captivePortalCallback.expectLinkPropertiesThat(mWiFiNetworkAgent,
+ captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
lp -> captivePortalTestData.mExpectedMergedPasspointData
.equals(lp.getCaptivePortalData()));
// Now send this information from non-Passpoint source, confirm that Capport data takes
// precedence
linkProperties.setCaptivePortalData(captivePortalTestData.mNaOtherData);
- mWiFiNetworkAgent.sendLinkProperties(linkProperties);
+ mWiFiAgent.sendLinkProperties(linkProperties);
// Make sure that the capport data is merged
- captivePortalCallback.expectLinkPropertiesThat(mWiFiNetworkAgent,
+ captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
lp -> captivePortalTestData.mExpectedMergedOtherData
.equals(lp.getCaptivePortalData()));
// Create a new LP with no Network agent capport data
final LinkProperties newLps = new LinkProperties();
newLps.setMtu(1234);
- mWiFiNetworkAgent.sendLinkProperties(newLps);
+ mWiFiAgent.sendLinkProperties(newLps);
// CaptivePortalData is not lost and has the original values when LPs are received from the
// NetworkAgent
- captivePortalCallback.expectLinkPropertiesThat(mWiFiNetworkAgent,
+ captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
lp -> captivePortalTestData.mCapportData.equals(lp.getCaptivePortalData())
&& lp.getMtu() == 1234);
// Now send capport data only from the Network agent
- mWiFiNetworkAgent.notifyCapportApiDataChanged(null);
- captivePortalCallback.expectLinkPropertiesThat(mWiFiNetworkAgent,
+ mWiFiAgent.notifyCapportApiDataChanged(null);
+ captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
lp -> lp.getCaptivePortalData() == null);
newLps.setCaptivePortalData(captivePortalTestData.mNaPasspointData);
- mWiFiNetworkAgent.sendLinkProperties(newLps);
+ mWiFiAgent.sendLinkProperties(newLps);
// Make sure that only the network agent capport data is available
- captivePortalCallback.expectLinkPropertiesThat(mWiFiNetworkAgent,
+ captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
lp -> captivePortalTestData.mNaPasspointData.equals(lp.getCaptivePortalData()));
}
@@ -4818,27 +4802,27 @@
// on the bytes remaining.
final LinkProperties linkProperties = new LinkProperties();
linkProperties.setCaptivePortalData(captivePortalTestData.mNaPasspointData);
- mWiFiNetworkAgent.sendLinkProperties(linkProperties);
+ mWiFiAgent.sendLinkProperties(linkProperties);
// Make sure that the data is saved correctly
- captivePortalCallback.expectLinkPropertiesThat(mWiFiNetworkAgent,
+ captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
lp -> captivePortalTestData.mNaPasspointData.equals(lp.getCaptivePortalData()));
// Expected merged data: Network agent data is preferred, and values that are not used by
// it are merged from capport data
- mWiFiNetworkAgent.notifyCapportApiDataChanged(captivePortalTestData.mCapportData);
+ mWiFiAgent.notifyCapportApiDataChanged(captivePortalTestData.mCapportData);
// Make sure that the Capport data is merged correctly
- captivePortalCallback.expectLinkPropertiesThat(mWiFiNetworkAgent,
+ captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
lp -> captivePortalTestData.mExpectedMergedPasspointData.equals(
lp.getCaptivePortalData()));
// Now set the naData to null
linkProperties.setCaptivePortalData(null);
- mWiFiNetworkAgent.sendLinkProperties(linkProperties);
+ mWiFiAgent.sendLinkProperties(linkProperties);
// Make sure that the Capport data is retained correctly
- captivePortalCallback.expectLinkPropertiesThat(mWiFiNetworkAgent,
+ captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
lp -> captivePortalTestData.mCapportData.equals(lp.getCaptivePortalData()));
}
@@ -4852,18 +4836,18 @@
// on the bytes remaining.
final LinkProperties linkProperties = new LinkProperties();
linkProperties.setCaptivePortalData(captivePortalTestData.mNaOtherData);
- mWiFiNetworkAgent.sendLinkProperties(linkProperties);
+ mWiFiAgent.sendLinkProperties(linkProperties);
// Make sure that the data is saved correctly
- captivePortalCallback.expectLinkPropertiesThat(mWiFiNetworkAgent,
+ captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
lp -> captivePortalTestData.mNaOtherData.equals(lp.getCaptivePortalData()));
// Expected merged data: Network agent data is preferred, and values that are not used by
// it are merged from capport data
- mWiFiNetworkAgent.notifyCapportApiDataChanged(captivePortalTestData.mCapportData);
+ mWiFiAgent.notifyCapportApiDataChanged(captivePortalTestData.mCapportData);
// Make sure that the Capport data is merged correctly
- captivePortalCallback.expectLinkPropertiesThat(mWiFiNetworkAgent,
+ captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
lp -> captivePortalTestData.mExpectedMergedOtherData.equals(
lp.getCaptivePortalData()));
}
@@ -4985,51 +4969,50 @@
LocalStringNetworkSpecifier nsFoo = new LocalStringNetworkSpecifier("foo");
LocalStringNetworkSpecifier nsBar = new LocalStringNetworkSpecifier("bar");
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
- expectAvailableCallbacksUnvalidatedWithSpecifier(mWiFiNetworkAgent, null /* specifier */,
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
+ expectAvailableCallbacksUnvalidatedWithSpecifier(mWiFiAgent, null /* specifier */,
cEmpty1, cEmpty2, cEmpty3, cEmpty4);
assertNoCallbacks(cFoo, cBar);
- mWiFiNetworkAgent.disconnect();
- expectOnLost(mWiFiNetworkAgent, cEmpty1, cEmpty2, cEmpty3, cEmpty4);
+ mWiFiAgent.disconnect();
+ expectOnLost(mWiFiAgent, cEmpty1, cEmpty2, cEmpty3, cEmpty4);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.setNetworkSpecifier(nsFoo);
- mWiFiNetworkAgent.connect(false);
- expectAvailableCallbacksUnvalidatedWithSpecifier(mWiFiNetworkAgent, nsFoo,
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.setNetworkSpecifier(nsFoo);
+ mWiFiAgent.connect(false);
+ expectAvailableCallbacksUnvalidatedWithSpecifier(mWiFiAgent, nsFoo,
cEmpty1, cEmpty2, cEmpty3, cEmpty4, cFoo);
cBar.assertNoCallback();
assertEquals(nsFoo,
- mCm.getNetworkCapabilities(mWiFiNetworkAgent.getNetwork()).getNetworkSpecifier());
+ mCm.getNetworkCapabilities(mWiFiAgent.getNetwork()).getNetworkSpecifier());
assertNoCallbacks(cEmpty1, cEmpty2, cEmpty3, cEmpty4, cFoo);
- mWiFiNetworkAgent.disconnect();
- expectOnLost(mWiFiNetworkAgent, cEmpty1, cEmpty2, cEmpty3, cEmpty4, cFoo);
+ mWiFiAgent.disconnect();
+ expectOnLost(mWiFiAgent, cEmpty1, cEmpty2, cEmpty3, cEmpty4, cFoo);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.setNetworkSpecifier(nsBar);
- mWiFiNetworkAgent.connect(false);
- expectAvailableCallbacksUnvalidatedWithSpecifier(mWiFiNetworkAgent, nsBar,
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.setNetworkSpecifier(nsBar);
+ mWiFiAgent.connect(false);
+ expectAvailableCallbacksUnvalidatedWithSpecifier(mWiFiAgent, nsBar,
cEmpty1, cEmpty2, cEmpty3, cEmpty4, cBar);
cFoo.assertNoCallback();
assertEquals(nsBar,
- mCm.getNetworkCapabilities(mWiFiNetworkAgent.getNetwork()).getNetworkSpecifier());
+ mCm.getNetworkCapabilities(mWiFiAgent.getNetwork()).getNetworkSpecifier());
- mWiFiNetworkAgent.disconnect();
- expectOnLost(mWiFiNetworkAgent, cEmpty1, cEmpty2, cEmpty3, cEmpty4, cBar);
+ mWiFiAgent.disconnect();
+ expectOnLost(mWiFiAgent, cEmpty1, cEmpty2, cEmpty3, cEmpty4, cBar);
cFoo.assertNoCallback();
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.setNetworkSpecifier(new ConfidentialMatchAllNetworkSpecifier());
- mWiFiNetworkAgent.connect(false);
- expectAvailableCallbacksUnvalidatedWithSpecifier(mWiFiNetworkAgent, null /* specifier */,
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.setNetworkSpecifier(new ConfidentialMatchAllNetworkSpecifier());
+ mWiFiAgent.connect(false);
+ expectAvailableCallbacksUnvalidatedWithSpecifier(mWiFiAgent, null /* specifier */,
cEmpty1, cEmpty2, cEmpty3, cEmpty4, cFoo, cBar);
- assertNull(
- mCm.getNetworkCapabilities(mWiFiNetworkAgent.getNetwork()).getNetworkSpecifier());
+ assertNull(mCm.getNetworkCapabilities(mWiFiAgent.getNetwork()).getNetworkSpecifier());
- mWiFiNetworkAgent.disconnect();
- expectOnLost(mWiFiNetworkAgent, cEmpty1, cEmpty2, cEmpty3, cEmpty4, cFoo, cBar);
+ mWiFiAgent.disconnect();
+ expectOnLost(mWiFiAgent, cEmpty1, cEmpty2, cEmpty3, cEmpty4, cFoo, cBar);
}
/**
@@ -5108,8 +5091,8 @@
@Test
public void testNetworkRequestUidSpoofSecurityException() throws Exception {
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
NetworkRequest networkRequest = newWifiRequestBuilder().build();
TestNetworkCallback networkCallback = new TestNetworkCallback();
doThrow(new SecurityException()).when(mAppOpsManager).checkPackage(anyInt(), anyString());
@@ -5164,35 +5147,35 @@
cellNetworkCallback.assertNoCallback();
// Bring up cell and expect CALLBACK_AVAILABLE.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- defaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- systemDefaultCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ defaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ systemDefaultCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
assertEquals(defaultNetworkCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
assertEquals(systemDefaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
// Bring up wifi and expect CALLBACK_AVAILABLE.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
cellNetworkCallback.assertNoCallback();
- defaultNetworkCallback.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
- systemDefaultCallback.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
+ defaultNetworkCallback.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
+ systemDefaultCallback.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
assertEquals(defaultNetworkCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
assertEquals(systemDefaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
// Bring down cell. Expect no default network callback, since it wasn't the default.
- mCellNetworkAgent.disconnect();
- cellNetworkCallback.expect(LOST, mCellNetworkAgent);
+ mCellAgent.disconnect();
+ cellNetworkCallback.expect(LOST, mCellAgent);
defaultNetworkCallback.assertNoCallback();
systemDefaultCallback.assertNoCallback();
assertEquals(defaultNetworkCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
assertEquals(systemDefaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
// Bring up cell. Expect no default network callback, since it won't be the default.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
defaultNetworkCallback.assertNoCallback();
systemDefaultCallback.assertNoCallback();
assertEquals(defaultNetworkCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
@@ -5200,16 +5183,16 @@
// Bring down wifi. Expect the default network callback to notified of LOST wifi
// followed by AVAILABLE cell.
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
cellNetworkCallback.assertNoCallback();
- defaultNetworkCallback.expect(LOST, mWiFiNetworkAgent);
- defaultNetworkCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
- systemDefaultCallback.expect(LOST, mWiFiNetworkAgent);
- systemDefaultCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
- mCellNetworkAgent.disconnect();
- cellNetworkCallback.expect(LOST, mCellNetworkAgent);
- defaultNetworkCallback.expect(LOST, mCellNetworkAgent);
- systemDefaultCallback.expect(LOST, mCellNetworkAgent);
+ defaultNetworkCallback.expect(LOST, mWiFiAgent);
+ defaultNetworkCallback.expectAvailableCallbacksValidated(mCellAgent);
+ systemDefaultCallback.expect(LOST, mWiFiAgent);
+ systemDefaultCallback.expectAvailableCallbacksValidated(mCellAgent);
+ mCellAgent.disconnect();
+ cellNetworkCallback.expect(LOST, mCellAgent);
+ defaultNetworkCallback.expect(LOST, mCellAgent);
+ systemDefaultCallback.expect(LOST, mCellAgent);
waitForIdle();
assertEquals(null, mCm.getActiveNetwork());
@@ -5236,28 +5219,27 @@
mCm.requestNetwork(cellRequest, cellNetworkCallback);
// Bring up the mobile network.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
// We should get onAvailable(), onCapabilitiesChanged(), and
// onLinkPropertiesChanged() in rapid succession. Additionally, we
// should get onCapabilitiesChanged() when the mobile network validates.
- cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
cellNetworkCallback.assertNoCallback();
// Update LinkProperties.
final LinkProperties lp = new LinkProperties();
lp.setInterfaceName("foonet_data0");
- mCellNetworkAgent.sendLinkProperties(lp);
+ mCellAgent.sendLinkProperties(lp);
// We should get onLinkPropertiesChanged().
- cellNetworkCallback.expect(LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
+ cellNetworkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
cellNetworkCallback.assertNoCallback();
// Suspend the network.
- mCellNetworkAgent.suspend();
- cellNetworkCallback.expectCapabilitiesWithout(NET_CAPABILITY_NOT_SUSPENDED,
- mCellNetworkAgent);
- cellNetworkCallback.expect(SUSPENDED, mCellNetworkAgent);
+ mCellAgent.suspend();
+ cellNetworkCallback.expectCapabilitiesWithout(NET_CAPABILITY_NOT_SUSPENDED, mCellAgent);
+ cellNetworkCallback.expect(SUSPENDED, mCellAgent);
cellNetworkCallback.assertNoCallback();
assertEquals(NetworkInfo.State.SUSPENDED, mCm.getActiveNetworkInfo().getState());
@@ -5266,21 +5248,20 @@
mCm.registerDefaultNetworkCallback(dfltNetworkCallback);
// We should get onAvailable(), onCapabilitiesChanged(), onLinkPropertiesChanged(),
// as well as onNetworkSuspended() in rapid succession.
- dfltNetworkCallback.expectAvailableAndSuspendedCallbacks(mCellNetworkAgent, true);
+ dfltNetworkCallback.expectAvailableAndSuspendedCallbacks(mCellAgent, true);
dfltNetworkCallback.assertNoCallback();
mCm.unregisterNetworkCallback(dfltNetworkCallback);
- mCellNetworkAgent.resume();
- cellNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_NOT_SUSPENDED,
- mCellNetworkAgent);
- cellNetworkCallback.expect(RESUMED, mCellNetworkAgent);
+ mCellAgent.resume();
+ cellNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_NOT_SUSPENDED, mCellAgent);
+ cellNetworkCallback.expect(RESUMED, mCellAgent);
cellNetworkCallback.assertNoCallback();
assertEquals(NetworkInfo.State.CONNECTED, mCm.getActiveNetworkInfo().getState());
dfltNetworkCallback = new TestNetworkCallback();
mCm.registerDefaultNetworkCallback(dfltNetworkCallback);
// This time onNetworkSuspended should not be called.
- dfltNetworkCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ dfltNetworkCallback.expectAvailableCallbacksValidated(mCellAgent);
dfltNetworkCallback.assertNoCallback();
mCm.unregisterNetworkCallback(dfltNetworkCallback);
@@ -5289,8 +5270,8 @@
@Test
public void testRegisterPrivilegedDefaultCallbacksRequirePermissions() throws Exception {
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(false /* validated */);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(false /* validated */);
mServiceContext.setPermission(CONNECTIVITY_USE_RESTRICTED_NETWORKS, PERMISSION_DENIED);
final Handler handler = new Handler(ConnectivityThread.getInstanceLooper());
@@ -5305,16 +5286,16 @@
mServiceContext.setPermission(CONNECTIVITY_USE_RESTRICTED_NETWORKS, PERMISSION_GRANTED);
mCm.registerSystemDefaultNetworkCallback(callback, handler);
mServiceContext.setPermission(CONNECTIVITY_USE_RESTRICTED_NETWORKS, PERMISSION_DENIED);
- callback.expectAvailableCallbacksUnvalidated(mCellNetworkAgent);
+ callback.expectAvailableCallbacksUnvalidated(mCellAgent);
mCm.unregisterNetworkCallback(callback);
mServiceContext.setPermission(NETWORK_SETTINGS, PERMISSION_GRANTED);
mCm.registerSystemDefaultNetworkCallback(callback, handler);
- callback.expectAvailableCallbacksUnvalidated(mCellNetworkAgent);
+ callback.expectAvailableCallbacksUnvalidated(mCellAgent);
mCm.unregisterNetworkCallback(callback);
mCm.registerDefaultNetworkCallbackForUid(APP1_UID, callback, handler);
- callback.expectAvailableCallbacksUnvalidated(mCellNetworkAgent);
+ callback.expectAvailableCallbacksUnvalidated(mCellAgent);
mCm.unregisterNetworkCallback(callback);
}
@@ -5345,15 +5326,15 @@
mCm.registerNetworkCallback(includeOtherUidsRequest, includeOtherUidsCallback);
// Both callbacks see a network with no specifier that applies to their UID.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false /* validated */);
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- otherUidCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- includeOtherUidsCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- mWiFiNetworkAgent.disconnect();
- callback.expect(LOST, mWiFiNetworkAgent);
- otherUidCallback.expect(LOST, mWiFiNetworkAgent);
- includeOtherUidsCallback.expect(LOST, mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false /* validated */);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ otherUidCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ includeOtherUidsCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ mWiFiAgent.disconnect();
+ callback.expect(LOST, mWiFiAgent);
+ otherUidCallback.expect(LOST, mWiFiAgent);
+ includeOtherUidsCallback.expect(LOST, mWiFiAgent);
// Only the includeOtherUidsCallback sees a VPN that does not apply to its UID.
final UidRange range = UidRange.createForUser(UserHandle.of(RESTRICTED_USER));
@@ -5429,10 +5410,10 @@
final NetworkCapabilities ncTemplate = new NetworkCapabilities()
.addTransportType(TRANSPORT_WIFI)
.setNetworkSpecifier(specifier);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, emptyLp, ncTemplate);
- mWiFiNetworkAgent.connect(false /* validated */);
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- otherUidCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, emptyLp, ncTemplate);
+ mWiFiAgent.connect(false /* validated */);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ otherUidCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
includeOtherUidsCallback.assertNoCallback();
}
@@ -5487,63 +5468,63 @@
mCm.registerNetworkCallback(request, callback);
mCm.registerNetworkCallback(fgRequest, fgCallback);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- callback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- fgCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- assertTrue(isForegroundNetwork(mCellNetworkAgent));
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ callback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ fgCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ assertTrue(isForegroundNetwork(mCellAgent));
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
// When wifi connects, cell lingers.
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- callback.expectLosing(mCellNetworkAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
- fgCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- fgCallback.expectLosing(mCellNetworkAgent);
- fgCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
- assertTrue(isForegroundNetwork(mCellNetworkAgent));
- assertTrue(isForegroundNetwork(mWiFiNetworkAgent));
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ callback.expectLosing(mCellAgent);
+ callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ fgCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ fgCallback.expectLosing(mCellAgent);
+ fgCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ assertTrue(isForegroundNetwork(mCellAgent));
+ assertTrue(isForegroundNetwork(mWiFiAgent));
// When lingering is complete, cell is still there but is now in the background.
waitForIdle();
int timeoutMs = TEST_LINGER_DELAY_MS + TEST_LINGER_DELAY_MS / 4;
- fgCallback.expect(LOST, mCellNetworkAgent, timeoutMs);
+ fgCallback.expect(LOST, mCellAgent, timeoutMs);
// Expect a network capabilities update sans FOREGROUND.
- callback.expectCapabilitiesWithout(NET_CAPABILITY_FOREGROUND, mCellNetworkAgent);
- assertFalse(isForegroundNetwork(mCellNetworkAgent));
- assertTrue(isForegroundNetwork(mWiFiNetworkAgent));
+ callback.expectCapabilitiesWithout(NET_CAPABILITY_FOREGROUND, mCellAgent);
+ assertFalse(isForegroundNetwork(mCellAgent));
+ assertTrue(isForegroundNetwork(mWiFiAgent));
// File a cell request and check that cell comes into the foreground.
final NetworkRequest cellRequest = new NetworkRequest.Builder()
.addTransportType(TRANSPORT_CELLULAR).build();
final TestNetworkCallback cellCallback = new TestNetworkCallback();
mCm.requestNetwork(cellRequest, cellCallback);
- cellCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
- fgCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ cellCallback.expectAvailableCallbacksValidated(mCellAgent);
+ fgCallback.expectAvailableCallbacksValidated(mCellAgent);
// Expect a network capabilities update with FOREGROUND, because the most recent
// request causes its state to change.
- cellCallback.expectCapabilitiesWith(NET_CAPABILITY_FOREGROUND, mCellNetworkAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_FOREGROUND, mCellNetworkAgent);
- assertTrue(isForegroundNetwork(mCellNetworkAgent));
- assertTrue(isForegroundNetwork(mWiFiNetworkAgent));
+ cellCallback.expectCapabilitiesWith(NET_CAPABILITY_FOREGROUND, mCellAgent);
+ callback.expectCapabilitiesWith(NET_CAPABILITY_FOREGROUND, mCellAgent);
+ assertTrue(isForegroundNetwork(mCellAgent));
+ assertTrue(isForegroundNetwork(mWiFiAgent));
// Release the request. The network immediately goes into the background, since it was not
// lingering.
mCm.unregisterNetworkCallback(cellCallback);
- fgCallback.expect(LOST, mCellNetworkAgent);
+ fgCallback.expect(LOST, mCellAgent);
// Expect a network capabilities update sans FOREGROUND.
- callback.expectCapabilitiesWithout(NET_CAPABILITY_FOREGROUND, mCellNetworkAgent);
- assertFalse(isForegroundNetwork(mCellNetworkAgent));
- assertTrue(isForegroundNetwork(mWiFiNetworkAgent));
+ callback.expectCapabilitiesWithout(NET_CAPABILITY_FOREGROUND, mCellAgent);
+ assertFalse(isForegroundNetwork(mCellAgent));
+ assertTrue(isForegroundNetwork(mWiFiAgent));
// Disconnect wifi and check that cell is foreground again.
- mWiFiNetworkAgent.disconnect();
- callback.expect(LOST, mWiFiNetworkAgent);
- fgCallback.expect(LOST, mWiFiNetworkAgent);
- fgCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
- assertTrue(isForegroundNetwork(mCellNetworkAgent));
+ mWiFiAgent.disconnect();
+ callback.expect(LOST, mWiFiAgent);
+ fgCallback.expect(LOST, mWiFiAgent);
+ fgCallback.expectAvailableCallbacksValidated(mCellAgent);
+ assertTrue(isForegroundNetwork(mCellAgent));
mCm.unregisterNetworkCallback(callback);
mCm.unregisterNetworkCallback(fgCallback);
@@ -5584,11 +5565,11 @@
}
});
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
// Don't request that the network validate, because otherwise connect() will block until
// the network gets NET_CAPABILITY_VALIDATED, after all the callbacks below have fired,
// and we won't actually measure anything.
- mCellNetworkAgent.connect(false);
+ mCellAgent.connect(false);
long onAvailableDispatchingDuration = durationOf(() -> {
await(availableLatch, 10 * CONNECT_TIME_LIMIT_MS);
@@ -5601,9 +5582,9 @@
onAvailableDispatchingDuration <= CONNECT_TIME_LIMIT_MS);
// Give wifi a high enough score that we'll linger cell when wifi comes up.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.adjustScore(40);
- mWiFiNetworkAgent.connect(false);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.adjustScore(40);
+ mWiFiAgent.connect(false);
long onLostDispatchingDuration = durationOf(() -> {
await(losingLatch, 10 * SWITCH_TIME_LIMIT_MS);
@@ -5649,9 +5630,9 @@
assertTrue(testFactory.getMyStartRequested());
// Bring up wifi. The factory stops looking for a network.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
// Score 60 - 40 penalty for not validated yet, then 60 when it validates
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent.connect(true);
// The network connects with a low score, so the offer can still beat it and
// nothing happens. Then the network validates, and the offer with its filter score
// of 40 can no longer beat it and the request is removed.
@@ -5670,9 +5651,9 @@
// Bring up cell data and check that the factory stops looking.
assertLength(1, mCm.getAllNetworks());
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(false);
- cellNetworkCallback.expectAvailableCallbacks(mCellNetworkAgent, false, false, false,
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(false);
+ cellNetworkCallback.expectAvailableCallbacks(mCellAgent, false, false, false,
TEST_CALLBACK_TIMEOUT_MS);
// When cell connects, it will satisfy the "mobile always on request" right away
// by virtue of being the only network that can satisfy the request. However, its
@@ -5682,11 +5663,11 @@
// Next, cell validates. This gives it a score of 50 and the test factory can't
// hope to beat that according to its filters. It will see the message that its
// offer is now unnecessary.
- mCellNetworkAgent.setNetworkValid(true);
+ mCellAgent.setNetworkValid(true);
// Need a trigger point to let NetworkMonitor tell ConnectivityService that network is
// validated – see testPartialConnectivity.
- mCm.reportNetworkConnectivity(mCellNetworkAgent.getNetwork(), true);
- cellNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mCellNetworkAgent);
+ mCm.reportNetworkConnectivity(mCellAgent.getNetwork(), true);
+ cellNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mCellAgent);
testFactory.expectRequestRemove();
testFactory.assertRequestCountEquals(0);
// Accordingly, the factory shouldn't be started.
@@ -5699,8 +5680,8 @@
// Cell disconnects. There is still the "mobile data always on" request outstanding,
// and the test factory should see it now that it isn't hopelessly outscored.
- mCellNetworkAgent.disconnect();
- cellNetworkCallback.expect(LOST, mCellNetworkAgent);
+ mCellAgent.disconnect();
+ cellNetworkCallback.expect(LOST, mCellAgent);
// Wait for the network to be removed from internal structures before
// calling synchronous getter
waitForIdle();
@@ -5711,9 +5692,9 @@
// Reconnect cell validated, see the request disappear again. Then withdraw the
// mobile always on request. This will tear down cell, and there shouldn't be a
// blip where the test factory briefly sees the request or anything.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
waitForIdle();
assertLength(2, mCm.getAllNetworks());
testFactory.expectRequestRemove();
@@ -5723,7 +5704,7 @@
testFactory.assertRequestCountEquals(0);
assertFalse(testFactory.getMyStartRequested());
// ... and cell data to be torn down immediately since it is no longer nascent.
- cellNetworkCallback.expect(LOST, mCellNetworkAgent);
+ cellNetworkCallback.expect(LOST, mCellAgent);
waitForIdle();
assertLength(1, mCm.getAllNetworks());
testFactory.terminate();
@@ -5868,39 +5849,39 @@
mCm.registerNetworkCallback(wifiRequest, wifiNetworkCallback);
// Cell connects and validates.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR,
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR,
new LinkProperties(), null /* ncTemplate */, cellProvider);
- mCellNetworkAgent.connect(true);
- cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent.connect(true);
+ cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
cellCallback.assertNoCallback();
wifiCallback.assertNoCallback();
// Bring up wifi. At first it's invalidated, so cell is still needed.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI,
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI,
new LinkProperties(), null /* ncTemplate */, wifiProvider);
- mWiFiNetworkAgent.connect(false);
- wifiNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mWiFiAgent.connect(false);
+ wifiNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
cellCallback.assertNoCallback();
wifiCallback.assertNoCallback();
// Wifi validates. Cell is no longer needed, because it's outscored.
- mWiFiNetworkAgent.setNetworkValid(true /* privateDnsProbeSent */);
+ mWiFiAgent.setNetworkValid(true /* privateDnsProbeSent */);
// Have CS reconsider the network (see testPartialConnectivity)
- mCm.reportNetworkConnectivity(mWiFiNetworkAgent.getNetwork(), true);
- wifiNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
+ mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), true);
+ wifiNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
cellCallback.expectOnNetworkUnneeded(defaultCaps);
wifiCallback.assertNoCallback();
// Wifi is no longer validated. Cell is needed again.
- mWiFiNetworkAgent.setNetworkInvalid(true /* invalidBecauseOfPrivateDns */);
- mCm.reportNetworkConnectivity(mWiFiNetworkAgent.getNetwork(), false);
- wifiNetworkCallback.expectCapabilitiesWithout(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
+ mWiFiAgent.setNetworkInvalid(true /* invalidBecauseOfPrivateDns */);
+ mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), false);
+ wifiNetworkCallback.expectCapabilitiesWithout(NET_CAPABILITY_VALIDATED, mWiFiAgent);
cellCallback.expectOnNetworkNeeded(defaultCaps);
wifiCallback.assertNoCallback();
// Disconnect wifi and pretend the carrier restricts moving away from bad wifi.
- mWiFiNetworkAgent.disconnect();
- wifiNetworkCallback.expect(LOST, mWiFiNetworkAgent);
+ mWiFiAgent.disconnect();
+ wifiNetworkCallback.expect(LOST, mWiFiAgent);
// This has getAvoidBadWifi return false. This test doesn't change the value of the
// associated setting.
doReturn(0).when(mResources).getInteger(R.integer.config_networkAvoidBadWifi);
@@ -5908,23 +5889,23 @@
waitForIdle();
// Connect wifi again, cell is needed until wifi validates.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI,
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI,
new LinkProperties(), null /* ncTemplate */, wifiProvider);
- mWiFiNetworkAgent.connect(false);
- wifiNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mWiFiAgent.connect(false);
+ wifiNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
cellCallback.assertNoCallback();
wifiCallback.assertNoCallback();
- mWiFiNetworkAgent.setNetworkValid(true /* privateDnsProbeSent */);
- mCm.reportNetworkConnectivity(mWiFiNetworkAgent.getNetwork(), true);
- wifiNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
+ mWiFiAgent.setNetworkValid(true /* privateDnsProbeSent */);
+ mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), true);
+ wifiNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
cellCallback.expectOnNetworkUnneeded(defaultCaps);
wifiCallback.assertNoCallback();
// Wifi loses validation. Because the device doesn't avoid bad wifis, cell is
// not needed.
- mWiFiNetworkAgent.setNetworkInvalid(true /* invalidBecauseOfPrivateDns */);
- mCm.reportNetworkConnectivity(mWiFiNetworkAgent.getNetwork(), false);
- wifiNetworkCallback.expectCapabilitiesWithout(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
+ mWiFiAgent.setNetworkInvalid(true /* invalidBecauseOfPrivateDns */);
+ mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), false);
+ wifiNetworkCallback.expectCapabilitiesWithout(NET_CAPABILITY_VALIDATED, mWiFiAgent);
cellCallback.assertNoCallback();
wifiCallback.assertNoCallback();
}
@@ -5946,19 +5927,19 @@
mCm.registerNetworkCallback(wifiRequest, wifiCallback);
// Bring up validated cell and unvalidated wifi.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
- wifiCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
+ wifiCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
if (preferBadWifi) {
- expectUnvalidationCheckWillNotify(mWiFiNetworkAgent, NotificationType.LOST_INTERNET);
- mDefaultNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ expectUnvalidationCheckWillNotify(mWiFiAgent, NotificationType.LOST_INTERNET);
+ mDefaultNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
} else {
- expectUnvalidationCheckWillNotNotify(mWiFiNetworkAgent);
+ expectUnvalidationCheckWillNotNotify(mWiFiAgent);
mDefaultNetworkCallback.assertNoCallback();
}
}
@@ -6003,25 +5984,25 @@
mPolicyTracker.reevaluate();
// Bring up validated cell.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- defaultCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- Network cellNetwork = mCellNetworkAgent.getNetwork();
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ defaultCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ Network cellNetwork = mCellAgent.getNetwork();
// Bring up validated wifi.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
- defaultCallback.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
- validatedWifiCallback.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
- Network wifiNetwork = mWiFiNetworkAgent.getNetwork();
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
+ defaultCallback.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
+ validatedWifiCallback.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
+ Network wifiNetwork = mWiFiAgent.getNetwork();
// Fail validation on wifi.
- mWiFiNetworkAgent.setNetworkInvalid(false /* invalidBecauseOfPrivateDns */);
+ mWiFiAgent.setNetworkInvalid(false /* invalidBecauseOfPrivateDns */);
mCm.reportNetworkConnectivity(wifiNetwork, false);
- defaultCallback.expectCapabilitiesWithout(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
- validatedWifiCallback.expect(LOST, mWiFiNetworkAgent);
- expectNotification(mWiFiNetworkAgent, NotificationType.LOST_INTERNET);
+ defaultCallback.expectCapabilitiesWithout(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ validatedWifiCallback.expect(LOST, mWiFiAgent);
+ expectNotification(mWiFiAgent, NotificationType.LOST_INTERNET);
// Because avoid bad wifi is off, we don't switch to cellular.
defaultCallback.assertNoCallback();
@@ -6035,24 +6016,24 @@
// that we switch back to cell.
doReturn(1).when(mResources).getInteger(R.integer.config_networkAvoidBadWifi);
mPolicyTracker.reevaluate();
- defaultCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ defaultCallback.expectAvailableCallbacksValidated(mCellAgent);
assertEquals(mCm.getActiveNetwork(), cellNetwork);
- expectClearNotification(mWiFiNetworkAgent, NotificationType.LOST_INTERNET);
+ expectClearNotification(mWiFiAgent, NotificationType.LOST_INTERNET);
// Switch back to a restrictive carrier.
doReturn(0).when(mResources).getInteger(R.integer.config_networkAvoidBadWifi);
mPolicyTracker.reevaluate();
- defaultCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ defaultCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
assertEquals(mCm.getActiveNetwork(), wifiNetwork);
// A notification was already shown for this very network.
- expectNoNotification(mWiFiNetworkAgent);
+ expectNoNotification(mWiFiAgent);
// Simulate the user selecting "switch" on the dialog, and check that we switch to cell.
// In principle this is a little bit unrealistic because the switch to a less restrictive
// carrier above should have remove the notification but this doesn't matter for the
// purposes of this test.
mCm.setAvoidUnvalidated(wifiNetwork);
- defaultCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ defaultCallback.expectAvailableCallbacksValidated(mCellAgent);
assertFalse(mCm.getNetworkCapabilities(wifiNetwork).hasCapability(
NET_CAPABILITY_VALIDATED));
assertTrue(mCm.getNetworkCapabilities(cellNetwork).hasCapability(
@@ -6060,54 +6041,54 @@
assertEquals(mCm.getActiveNetwork(), cellNetwork);
// Disconnect and reconnect wifi to clear the one-time switch above.
- mWiFiNetworkAgent.disconnect();
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
- defaultCallback.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
- validatedWifiCallback.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
- wifiNetwork = mWiFiNetworkAgent.getNetwork();
+ mWiFiAgent.disconnect();
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
+ defaultCallback.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
+ validatedWifiCallback.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
+ wifiNetwork = mWiFiAgent.getNetwork();
// Fail validation on wifi and expect the dialog to appear.
- mWiFiNetworkAgent.setNetworkInvalid(false /* invalidBecauseOfPrivateDns */);
+ mWiFiAgent.setNetworkInvalid(false /* invalidBecauseOfPrivateDns */);
mCm.reportNetworkConnectivity(wifiNetwork, false);
- defaultCallback.expectCapabilitiesWithout(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
- validatedWifiCallback.expect(LOST, mWiFiNetworkAgent);
- expectNotification(mWiFiNetworkAgent, NotificationType.LOST_INTERNET);
+ defaultCallback.expectCapabilitiesWithout(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ validatedWifiCallback.expect(LOST, mWiFiAgent);
+ expectNotification(mWiFiAgent, NotificationType.LOST_INTERNET);
// Simulate the user selecting "switch" and checking the don't ask again checkbox.
Settings.Global.putInt(cr, ConnectivitySettingsManager.NETWORK_AVOID_BAD_WIFI, 1);
mPolicyTracker.reevaluate();
// We now switch to cell.
- defaultCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ defaultCallback.expectAvailableCallbacksValidated(mCellAgent);
assertFalse(mCm.getNetworkCapabilities(wifiNetwork).hasCapability(
NET_CAPABILITY_VALIDATED));
assertTrue(mCm.getNetworkCapabilities(cellNetwork).hasCapability(
NET_CAPABILITY_VALIDATED));
assertEquals(mCm.getActiveNetwork(), cellNetwork);
- expectClearNotification(mWiFiNetworkAgent, NotificationType.LOST_INTERNET);
+ expectClearNotification(mWiFiAgent, NotificationType.LOST_INTERNET);
// Simulate the user turning the cellular fallback setting off and then on.
// We switch to wifi and then to cell.
Settings.Global.putString(cr, ConnectivitySettingsManager.NETWORK_AVOID_BAD_WIFI, null);
mPolicyTracker.reevaluate();
- defaultCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ defaultCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
assertEquals(mCm.getActiveNetwork(), wifiNetwork);
// Notification is cleared again because CS doesn't particularly remember that it has
// cleared it before, and if it hasn't cleared it before then it should do so now.
- expectClearNotification(mWiFiNetworkAgent, NotificationType.LOST_INTERNET);
+ expectClearNotification(mWiFiAgent, NotificationType.LOST_INTERNET);
Settings.Global.putInt(cr, ConnectivitySettingsManager.NETWORK_AVOID_BAD_WIFI, 1);
mPolicyTracker.reevaluate();
- defaultCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ defaultCallback.expectAvailableCallbacksValidated(mCellAgent);
assertEquals(mCm.getActiveNetwork(), cellNetwork);
// If cell goes down, we switch to wifi.
- mCellNetworkAgent.disconnect();
- defaultCallback.expect(LOST, mCellNetworkAgent);
- defaultCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mCellAgent.disconnect();
+ defaultCallback.expect(LOST, mCellAgent);
+ defaultCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
validatedWifiCallback.assertNoCallback();
// Notification is cleared yet again because the device switched to wifi.
- expectClearNotification(mWiFiNetworkAgent, NotificationType.LOST_INTERNET);
+ expectClearNotification(mWiFiAgent, NotificationType.LOST_INTERNET);
mCm.unregisterNetworkCallback(cellNetworkCallback);
mCm.unregisterNetworkCallback(validatedWifiCallback);
@@ -6144,9 +6125,9 @@
final TestNetworkCallback networkCallback = new TestNetworkCallback();
mCm.requestNetwork(nr, networkCallback, TEST_REQUEST_TIMEOUT_MS);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
- networkCallback.expectAvailableCallbacks(mWiFiNetworkAgent, false, false, false,
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
+ networkCallback.expectAvailableCallbacks(mWiFiAgent, false, false, false,
TEST_CALLBACK_TIMEOUT_MS);
// pass timeout and validate that UNAVAILABLE is not called
@@ -6164,12 +6145,12 @@
final TestNetworkCallback networkCallback = new TestNetworkCallback();
mCm.requestNetwork(nr, networkCallback, TEST_REQUEST_TIMEOUT_MS);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
- networkCallback.expectAvailableCallbacks(mWiFiNetworkAgent, false, false, false,
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
+ networkCallback.expectAvailableCallbacks(mWiFiAgent, false, false, false,
TEST_CALLBACK_TIMEOUT_MS);
- mWiFiNetworkAgent.disconnect();
- networkCallback.expect(LOST, mWiFiNetworkAgent);
+ mWiFiAgent.disconnect();
+ networkCallback.expect(LOST, mWiFiAgent);
// Validate that UNAVAILABLE is not called
networkCallback.assertNoCallback();
@@ -6192,8 +6173,8 @@
networkCallback.expect(UNAVAILABLE);
// create a network satisfying request - validate that request not triggered
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
networkCallback.assertNoCallback();
}
@@ -6215,8 +6196,8 @@
networkCallback.assertNoCallback();
// create a network satisfying request - validate that request not triggered
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
networkCallback.assertNoCallback();
}
@@ -6454,18 +6435,18 @@
private Network connectKeepaliveNetwork(LinkProperties lp) throws Exception {
// Ensure the network is disconnected before anything else occurs
- if (mWiFiNetworkAgent != null) {
- assertNull(mCm.getNetworkCapabilities(mWiFiNetworkAgent.getNetwork()));
+ if (mWiFiAgent != null) {
+ assertNull(mCm.getNetworkCapabilities(mWiFiAgent.getNetwork()));
}
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
ExpectedBroadcast b = expectConnectivityAction(TYPE_WIFI, DetailedState.CONNECTED);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent.connect(true);
b.expectBroadcast();
verifyActiveNetwork(TRANSPORT_WIFI);
- mWiFiNetworkAgent.sendLinkProperties(lp);
+ mWiFiAgent.sendLinkProperties(lp);
waitForIdle();
- return mWiFiNetworkAgent.getNetwork();
+ return mWiFiAgent.getNetwork();
}
@Test
@@ -6522,10 +6503,10 @@
callback.expectError(PacketKeepalive.ERROR_HARDWARE_UNSUPPORTED);
// Check that a started keepalive can be stopped.
- mWiFiNetworkAgent.setStartKeepaliveEvent(PacketKeepalive.SUCCESS);
+ mWiFiAgent.setStartKeepaliveEvent(PacketKeepalive.SUCCESS);
ka = mCm.startNattKeepalive(myNet, validKaInterval, callback, myIPv4, 12345, dstIPv4);
callback.expectStarted();
- mWiFiNetworkAgent.setStopKeepaliveEvent(PacketKeepalive.SUCCESS);
+ mWiFiAgent.setStopKeepaliveEvent(PacketKeepalive.SUCCESS);
ka.stop();
callback.expectStopped();
@@ -6535,15 +6516,15 @@
callback.expectStarted();
bogusLp.removeLinkAddress(new LinkAddress(myIPv4, 25));
bogusLp.addLinkAddress(new LinkAddress(notMyIPv4, 25));
- mWiFiNetworkAgent.sendLinkProperties(bogusLp);
+ mWiFiAgent.sendLinkProperties(bogusLp);
callback.expectError(PacketKeepalive.ERROR_INVALID_IP_ADDRESS);
- mWiFiNetworkAgent.sendLinkProperties(lp);
+ mWiFiAgent.sendLinkProperties(lp);
// Check that a started keepalive is stopped correctly when the network disconnects.
ka = mCm.startNattKeepalive(myNet, validKaInterval, callback, myIPv4, 12345, dstIPv4);
callback.expectStarted();
- mWiFiNetworkAgent.disconnect();
- mWiFiNetworkAgent.expectDisconnected();
+ mWiFiAgent.disconnect();
+ mWiFiAgent.expectDisconnected();
callback.expectError(PacketKeepalive.ERROR_INVALID_NETWORK);
// ... and that stopping it after that has no adverse effects.
@@ -6554,15 +6535,15 @@
// Reconnect.
myNet = connectKeepaliveNetwork(lp);
- mWiFiNetworkAgent.setStartKeepaliveEvent(PacketKeepalive.SUCCESS);
+ mWiFiAgent.setStartKeepaliveEvent(PacketKeepalive.SUCCESS);
// Check that keepalive slots start from 1 and increment. The first one gets slot 1.
- mWiFiNetworkAgent.setExpectedKeepaliveSlot(1);
+ mWiFiAgent.setExpectedKeepaliveSlot(1);
ka = mCm.startNattKeepalive(myNet, validKaInterval, callback, myIPv4, 12345, dstIPv4);
callback.expectStarted();
// The second one gets slot 2.
- mWiFiNetworkAgent.setExpectedKeepaliveSlot(2);
+ mWiFiAgent.setExpectedKeepaliveSlot(2);
TestKeepaliveCallback callback2 = new TestKeepaliveCallback();
PacketKeepalive ka2 = mCm.startNattKeepalive(
myNet, validKaInterval, callback2, myIPv4, 6789, dstIPv4);
@@ -6572,7 +6553,7 @@
ka.stop();
callback.expectStopped();
- mWiFiNetworkAgent.setExpectedKeepaliveSlot(1);
+ mWiFiAgent.setExpectedKeepaliveSlot(1);
TestKeepaliveCallback callback3 = new TestKeepaliveCallback();
PacketKeepalive ka3 = mCm.startNattKeepalive(
myNet, validKaInterval, callback3, myIPv4, 9876, dstIPv4);
@@ -6674,12 +6655,12 @@
}
// Check that a started keepalive can be stopped.
- mWiFiNetworkAgent.setStartKeepaliveEvent(SocketKeepalive.SUCCESS);
+ mWiFiAgent.setStartKeepaliveEvent(SocketKeepalive.SUCCESS);
try (SocketKeepalive ka = mCm.createSocketKeepalive(
myNet, testSocket, myIPv4, dstIPv4, executor, callback)) {
ka.start(validKaInterval);
callback.expectStarted();
- mWiFiNetworkAgent.setStopKeepaliveEvent(SocketKeepalive.SUCCESS);
+ mWiFiAgent.setStopKeepaliveEvent(SocketKeepalive.SUCCESS);
ka.stop();
callback.expectStopped();
@@ -6708,9 +6689,9 @@
callback.expectStarted();
bogusLp.removeLinkAddress(new LinkAddress(myIPv4, 25));
bogusLp.addLinkAddress(new LinkAddress(notMyIPv4, 25));
- mWiFiNetworkAgent.sendLinkProperties(bogusLp);
+ mWiFiAgent.sendLinkProperties(bogusLp);
callback.expectError(SocketKeepalive.ERROR_INVALID_IP_ADDRESS);
- mWiFiNetworkAgent.sendLinkProperties(lp);
+ mWiFiAgent.sendLinkProperties(lp);
}
// Check that a started keepalive is stopped correctly when the network disconnects.
@@ -6718,21 +6699,20 @@
myNet, testSocket, myIPv4, dstIPv4, executor, callback)) {
ka.start(validKaInterval);
callback.expectStarted();
- mWiFiNetworkAgent.disconnect();
- mWiFiNetworkAgent.expectDisconnected();
+ mWiFiAgent.disconnect();
+ mWiFiAgent.expectDisconnected();
callback.expectError(SocketKeepalive.ERROR_INVALID_NETWORK);
// ... and that stopping it after that has no adverse effects.
waitForIdle();
- final Network myNetAlias = myNet;
- assertNull(mCm.getNetworkCapabilities(myNetAlias));
+ assertNull(mCm.getNetworkCapabilities(myNet));
ka.stop();
callback.assertNoCallback();
}
// Reconnect.
myNet = connectKeepaliveNetwork(lp);
- mWiFiNetworkAgent.setStartKeepaliveEvent(SocketKeepalive.SUCCESS);
+ mWiFiAgent.setStartKeepaliveEvent(SocketKeepalive.SUCCESS);
// Check that a stop followed by network disconnects does not result in crash.
try (SocketKeepalive ka = mCm.createSocketKeepalive(
@@ -6741,7 +6721,7 @@
callback.expectStarted();
// Delay the response of keepalive events in networkAgent long enough to make sure
// the follow-up network disconnection will be processed first.
- mWiFiNetworkAgent.setKeepaliveResponseDelay(3 * TIMEOUT_MS);
+ mWiFiAgent.setKeepaliveResponseDelay(3 * TIMEOUT_MS);
ka.stop();
// Call stop() twice shouldn't result in crash, b/182586681.
ka.stop();
@@ -6751,8 +6731,8 @@
waitForIdleSerialExecutor(executor, TIMEOUT_MS);
waitForIdle();
- mWiFiNetworkAgent.disconnect();
- mWiFiNetworkAgent.expectDisconnected();
+ mWiFiAgent.disconnect();
+ mWiFiAgent.expectDisconnected();
callback.expectStopped();
callback.assertNoCallback();
}
@@ -6760,20 +6740,18 @@
// Reconnect.
waitForIdle();
myNet = connectKeepaliveNetwork(lp);
- mWiFiNetworkAgent.setStartKeepaliveEvent(SocketKeepalive.SUCCESS);
+ mWiFiAgent.setStartKeepaliveEvent(SocketKeepalive.SUCCESS);
// Check that keepalive slots start from 1 and increment. The first one gets slot 1.
- mWiFiNetworkAgent.setExpectedKeepaliveSlot(1);
- int srcPort2 = 0;
+ mWiFiAgent.setExpectedKeepaliveSlot(1);
try (SocketKeepalive ka = mCm.createSocketKeepalive(
myNet, testSocket, myIPv4, dstIPv4, executor, callback)) {
ka.start(validKaInterval);
callback.expectStarted();
// The second one gets slot 2.
- mWiFiNetworkAgent.setExpectedKeepaliveSlot(2);
+ mWiFiAgent.setExpectedKeepaliveSlot(2);
final UdpEncapsulationSocket testSocket2 = mIpSec.openUdpEncapsulationSocket();
- srcPort2 = testSocket2.getPort();
TestSocketKeepaliveCallback callback2 = new TestSocketKeepaliveCallback(executor);
try (SocketKeepalive ka2 = mCm.createSocketKeepalive(
myNet, testSocket2, myIPv4, dstIPv4, executor, callback2)) {
@@ -6796,9 +6774,9 @@
// assertFalse(isUdpPortInUse(srcPort));
// assertFalse(isUdpPortInUse(srcPort2));
- mWiFiNetworkAgent.disconnect();
- mWiFiNetworkAgent.expectDisconnected();
- mWiFiNetworkAgent = null;
+ mWiFiAgent.disconnect();
+ mWiFiAgent.expectDisconnected();
+ mWiFiAgent = null;
}
@Test
@@ -6872,9 +6850,9 @@
testSocketV4.close();
testSocketV6.close();
- mWiFiNetworkAgent.disconnect();
- mWiFiNetworkAgent.expectDisconnected();
- mWiFiNetworkAgent = null;
+ mWiFiAgent.disconnect();
+ mWiFiAgent.expectDisconnected();
+ mWiFiAgent = null;
}
private void doTestNattSocketKeepalivesFdWithExecutor(Executor executor) throws Exception {
@@ -6889,8 +6867,8 @@
lp.addLinkAddress(new LinkAddress(myIPv4, 25));
lp.addRoute(new RouteInfo(InetAddress.getByName("192.0.2.254")));
Network myNet = connectKeepaliveNetwork(lp);
- mWiFiNetworkAgent.setStartKeepaliveEvent(SocketKeepalive.SUCCESS);
- mWiFiNetworkAgent.setStopKeepaliveEvent(SocketKeepalive.SUCCESS);
+ mWiFiAgent.setStartKeepaliveEvent(SocketKeepalive.SUCCESS);
+ mWiFiAgent.setStopKeepaliveEvent(SocketKeepalive.SUCCESS);
TestSocketKeepaliveCallback callback = new TestSocketKeepaliveCallback(executor);
@@ -6925,9 +6903,9 @@
// TODO: enable this check after ensuring a valid free port. See b/129512753#comment7.
// assertFalse(isUdpPortInUse(srcPort));
- mWiFiNetworkAgent.disconnect();
- mWiFiNetworkAgent.expectDisconnected();
- mWiFiNetworkAgent = null;
+ mWiFiAgent.disconnect();
+ mWiFiAgent.expectDisconnected();
+ mWiFiAgent = null;
}
private static boolean isUdpPortInUse(int port) {
@@ -6965,18 +6943,18 @@
}
private void assertPinnedToWifiWithCellDefault() {
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getBoundNetworkForProcess());
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getBoundNetworkForProcess());
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
}
private void assertPinnedToWifiWithWifiDefault() {
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getBoundNetworkForProcess());
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getBoundNetworkForProcess());
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
}
private void assertNotPinnedToWifi() {
assertNull(mCm.getBoundNetworkForProcess());
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
}
@Test
@@ -6989,23 +6967,23 @@
TestNetworkPinner.pin(mServiceContext, wifiRequest);
assertNull(mCm.getBoundNetworkForProcess());
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
// When wi-fi connects, expect to be pinned.
assertTrue(TestNetworkPinner.awaitPin(100));
assertPinnedToWifiWithCellDefault();
// Disconnect and expect the pin to drop.
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
assertTrue(TestNetworkPinner.awaitUnpin(100));
assertNotPinnedToWifi();
// Reconnecting does not cause the pin to come back.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
assertFalse(TestNetworkPinner.awaitPin(100));
assertNotPinnedToWifi();
@@ -7020,21 +6998,21 @@
// Disconnect cell and wifi.
ExpectedBroadcast b = registerConnectivityBroadcast(3); // cell down, wifi up, wifi down.
- mCellNetworkAgent.disconnect();
- mWiFiNetworkAgent.disconnect();
+ mCellAgent.disconnect();
+ mWiFiAgent.disconnect();
b.expectBroadcast();
// Pinning takes effect even if the pinned network is the default when the pin is set...
TestNetworkPinner.pin(mServiceContext, wifiRequest);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
assertTrue(TestNetworkPinner.awaitPin(100));
assertPinnedToWifiWithWifiDefault();
// ... and is maintained even when that network is no longer the default.
b = registerConnectivityBroadcast(1);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mCellAgent.connect(true);
b.expectBroadcast();
assertPinnedToWifiWithCellDefault();
}
@@ -7365,15 +7343,15 @@
}
private List<Network> onlyCell() {
- return List.of(mCellNetworkAgent.getNetwork());
+ return List.of(mCellAgent.getNetwork());
}
private List<Network> onlyWifi() {
- return List.of(mWiFiNetworkAgent.getNetwork());
+ return List.of(mWiFiAgent.getNetwork());
}
private List<Network> cellAndWifi() {
- return List.of(mCellNetworkAgent.getNetwork(), mWiFiNetworkAgent.getNetwork());
+ return List.of(mCellAgent.getNetwork(), mWiFiAgent.getNetwork());
}
@Test
@@ -7383,11 +7361,11 @@
LinkProperties wifiLp = new LinkProperties();
wifiLp.setInterfaceName(WIFI_IFNAME);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
// Simple connection with initial LP should have updated ifaces.
- mCellNetworkAgent.connect(false);
+ mCellAgent.connect(false);
waitForIdle();
expectNotifyNetworkStatus(onlyCell(), onlyCell(), MOBILE_IFNAME);
reset(mStatsManager);
@@ -7397,13 +7375,13 @@
cellLp.addRoute(new RouteInfo((IpPrefix) null, InetAddress.getByName("192.0.2.4"),
MOBILE_IFNAME));
cellLp.setDnsServers(List.of(InetAddress.getAllByName("8.8.8.8")));
- mCellNetworkAgent.sendLinkProperties(cellLp);
+ mCellAgent.sendLinkProperties(cellLp);
verifyNoMoreInteractions(mStatsManager);
reset(mStatsManager);
// Default network switch should update ifaces.
- mWiFiNetworkAgent.connect(false);
- mWiFiNetworkAgent.sendLinkProperties(wifiLp);
+ mWiFiAgent.connect(false);
+ mWiFiAgent.sendLinkProperties(wifiLp);
waitForIdle();
assertEquals(wifiLp, mService.getActiveLinkProperties());
expectNotifyNetworkStatus(cellAndWifi(), onlyWifi(), WIFI_IFNAME);
@@ -7415,52 +7393,52 @@
// notifyNetworkStatus is called again, traffic on that interface will be accounted to the
// disconnected network. This is likely a bug in ConnectivityService; it should probably
// call notifyNetworkStatus again without the disconnected network.
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
waitForIdle();
expectNotifyNetworkStatus(cellAndWifi(), onlyWifi(), WIFI_IFNAME);
verifyNoMoreInteractions(mStatsManager);
reset(mStatsManager);
// Connecting a network updates ifaces even if the network doesn't become default.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
- mCellNetworkAgent.connect(false);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
+ mCellAgent.connect(false);
waitForIdle();
expectNotifyNetworkStatus(cellAndWifi(), onlyWifi(), WIFI_IFNAME);
reset(mStatsManager);
// Disconnect should update ifaces.
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
waitForIdle();
expectNotifyNetworkStatus(onlyCell(), onlyCell(), MOBILE_IFNAME);
reset(mStatsManager);
// Metered change should update ifaces
- mCellNetworkAgent.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED);
+ mCellAgent.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED);
waitForIdle();
expectNotifyNetworkStatus(onlyCell(), onlyCell(), MOBILE_IFNAME);
reset(mStatsManager);
- mCellNetworkAgent.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED);
+ mCellAgent.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED);
waitForIdle();
expectNotifyNetworkStatus(onlyCell(), onlyCell(), MOBILE_IFNAME);
reset(mStatsManager);
// Temp metered change shouldn't update ifaces
- mCellNetworkAgent.addCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED);
+ mCellAgent.addCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED);
waitForIdle();
verify(mStatsManager, never()).notifyNetworkStatus(eq(onlyCell()),
any(List.class), eq(MOBILE_IFNAME), any(List.class));
reset(mStatsManager);
// Congested change shouldn't update ifaces
- mCellNetworkAgent.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_CONGESTED);
+ mCellAgent.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_CONGESTED);
waitForIdle();
verify(mStatsManager, never()).notifyNetworkStatus(eq(onlyCell()),
any(List.class), eq(MOBILE_IFNAME), any(List.class));
reset(mStatsManager);
// Roaming change should update ifaces
- mCellNetworkAgent.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_ROAMING);
+ mCellAgent.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_ROAMING);
waitForIdle();
expectNotifyNetworkStatus(onlyCell(), onlyCell(), MOBILE_IFNAME);
reset(mStatsManager);
@@ -7472,25 +7450,22 @@
mMockVpn.establishForMyUid(lp);
assertUidRangesUpdatedForMyUid(true);
- final List<Network> cellAndVpn =
- List.of(mCellNetworkAgent.getNetwork(), mMockVpn.getNetwork());
+ final List<Network> cellAndVpn = List.of(mCellAgent.getNetwork(), mMockVpn.getNetwork());
// A VPN with default (null) underlying networks sets the underlying network's interfaces...
expectNotifyNetworkStatus(cellAndVpn, cellAndVpn, MOBILE_IFNAME, Process.myUid(),
VPN_IFNAME, List.of(MOBILE_IFNAME));
// ...and updates them as the default network switches.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
- mWiFiNetworkAgent.sendLinkProperties(wifiLp);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
+ mWiFiAgent.sendLinkProperties(wifiLp);
final Network[] onlyNull = new Network[]{null};
- final List<Network> wifiAndVpn =
- List.of(mWiFiNetworkAgent.getNetwork(), mMockVpn.getNetwork());
- final List<Network> cellWifiAndVpn =
- List.of(mCellNetworkAgent.getNetwork(), mWiFiNetworkAgent.getNetwork(),
- mMockVpn.getNetwork());
+ final List<Network> wifiAndVpn = List.of(mWiFiAgent.getNetwork(), mMockVpn.getNetwork());
+ final List<Network> cellWifiAndVpn = List.of(mCellAgent.getNetwork(),
+ mWiFiAgent.getNetwork(), mMockVpn.getNetwork());
final Network[] cellNullAndWifi =
- new Network[]{mCellNetworkAgent.getNetwork(), null, mWiFiNetworkAgent.getNetwork()};
+ new Network[] { mCellAgent.getNetwork(), null, mWiFiAgent.getNetwork() };
waitForIdle();
assertEquals(wifiLp, mService.getActiveLinkProperties());
@@ -7530,9 +7505,9 @@
// could result in incorrect data usage measurements if the interface used by the
// disconnected network is reused by a system component that does not register an agent for
// it (e.g., tethering).
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
waitForIdle();
- assertNull(mService.getLinkProperties(mCellNetworkAgent.getNetwork()));
+ assertNull(mService.getLinkProperties(mCellAgent.getNetwork()));
expectNotifyNetworkStatus(cellWifiAndVpn, wifiAndVpn, MOBILE_IFNAME, Process.myUid(),
VPN_IFNAME, List.of(MOBILE_IFNAME, WIFI_IFNAME));
@@ -7548,16 +7523,16 @@
// ... but if something else happens that causes notifyIfacesChangedForNetworkStats to be
// called again, it does. For example, connect Ethernet, but with a low score, such that it
// does not become the default network.
- mEthernetNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_ETHERNET);
- mEthernetNetworkAgent.setScore(
+ mEthernetAgent = new TestNetworkAgentWrapper(TRANSPORT_ETHERNET);
+ mEthernetAgent.setScore(
new NetworkScore.Builder().setLegacyInt(30).setExiting(true).build());
- mEthernetNetworkAgent.connect(false);
+ mEthernetAgent.connect(false);
waitForIdle();
verify(mStatsManager).notifyNetworkStatus(any(List.class),
any(List.class), any() /* anyString() doesn't match null */,
argThat(vpnInfos -> vpnInfos.get(0).getUnderlyingInterfaces().size() == 1
&& WIFI_IFNAME.equals(vpnInfos.get(0).getUnderlyingInterfaces().get(0))));
- mEthernetNetworkAgent.disconnect();
+ mEthernetAgent.disconnect();
waitForIdle();
reset(mStatsManager);
@@ -7597,18 +7572,18 @@
final int[] adminUids = new int[] {Process.myUid() + 1};
final NetworkCapabilities ncTemplate = new NetworkCapabilities();
ncTemplate.setAdministratorUids(adminUids);
- mCellNetworkAgent =
+ mCellAgent =
new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, new LinkProperties(), ncTemplate);
- mCellNetworkAgent.connect(false /* validated */);
+ mCellAgent.connect(false /* validated */);
// Verify case where caller has permission
mServiceContext.setPermission(
NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK, PERMISSION_GRANTED);
TestNetworkCallback callback = new TestNetworkCallback();
mCm.registerDefaultNetworkCallback(callback);
- callback.expect(AVAILABLE, mCellNetworkAgent);
+ callback.expect(AVAILABLE, mCellAgent);
callback.expectCapabilitiesThat(
- mCellNetworkAgent, nc -> Arrays.equals(adminUids, nc.getAdministratorUids()));
+ mCellAgent, nc -> Arrays.equals(adminUids, nc.getAdministratorUids()));
mCm.unregisterNetworkCallback(callback);
// Verify case where caller does NOT have permission
@@ -7617,9 +7592,8 @@
mServiceContext.setPermission(NETWORK_STACK, PERMISSION_DENIED);
callback = new TestNetworkCallback();
mCm.registerDefaultNetworkCallback(callback);
- callback.expect(AVAILABLE, mCellNetworkAgent);
- callback.expectCapabilitiesThat(
- mCellNetworkAgent, nc -> nc.getAdministratorUids().length == 0);
+ callback.expect(AVAILABLE, mCellAgent);
+ callback.expectCapabilitiesThat(mCellAgent, nc -> nc.getAdministratorUids().length == 0);
}
@Test
@@ -7636,10 +7610,10 @@
// Connect a VCN-managed wifi network.
final LinkProperties wifiLp = new LinkProperties();
wifiLp.setInterfaceName(WIFI_IFNAME);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
- mWiFiNetworkAgent.removeCapability(NET_CAPABILITY_NOT_VCN_MANAGED);
- mWiFiNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
- mWiFiNetworkAgent.connect(true /* validated */);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
+ mWiFiAgent.removeCapability(NET_CAPABILITY_NOT_VCN_MANAGED);
+ mWiFiAgent.addCapability(NET_CAPABILITY_NOT_METERED);
+ mWiFiAgent.connect(true /* validated */);
final List<Network> none = List.of();
expectNotifyNetworkStatus(onlyWifi(), none, null); // Wifi is not the default network
@@ -7654,7 +7628,7 @@
final LinkProperties lp = new LinkProperties();
lp.setInterfaceName(vcnIface);
final TestNetworkAgentWrapper vcn = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, lp, nc);
- vcn.setUnderlyingNetworks(List.of(mWiFiNetworkAgent.getNetwork()));
+ vcn.setUnderlyingNetworks(List.of(mWiFiAgent.getNetwork()));
vcn.connect(false /* validated */);
final TestNetworkCallback callback = new TestNetworkCallback();
@@ -7667,12 +7641,12 @@
assertFalse(nc.hasTransport(TRANSPORT_WIFI));
assertFalse(nc.hasCapability(NET_CAPABILITY_NOT_METERED));
final List<Network> onlyVcn = List.of(vcn.getNetwork());
- final List<Network> vcnAndWifi = List.of(vcn.getNetwork(), mWiFiNetworkAgent.getNetwork());
+ final List<Network> vcnAndWifi = List.of(vcn.getNetwork(), mWiFiAgent.getNetwork());
expectNotifyNetworkStatus(vcnAndWifi, onlyVcn, vcnIface, ownerUid, vcnIface,
List.of(WIFI_IFNAME));
// Add NOT_METERED to the underlying network, check that it is not propagated.
- mWiFiNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
+ mWiFiAgent.addCapability(NET_CAPABILITY_NOT_METERED);
callback.assertNoCallback();
nc = mCm.getNetworkCapabilities(vcn.getNetwork());
assertFalse(nc.hasCapability(NET_CAPABILITY_NOT_METERED));
@@ -7680,11 +7654,11 @@
// Switch underlying networks.
final LinkProperties cellLp = new LinkProperties();
cellLp.setInterfaceName(MOBILE_IFNAME);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
- mCellNetworkAgent.removeCapability(NET_CAPABILITY_NOT_VCN_MANAGED);
- mCellNetworkAgent.addCapability(NET_CAPABILITY_NOT_ROAMING);
- mCellNetworkAgent.connect(false /* validated */);
- vcn.setUnderlyingNetworks(List.of(mCellNetworkAgent.getNetwork()));
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
+ mCellAgent.removeCapability(NET_CAPABILITY_NOT_VCN_MANAGED);
+ mCellAgent.addCapability(NET_CAPABILITY_NOT_ROAMING);
+ mCellAgent.connect(false /* validated */);
+ vcn.setUnderlyingNetworks(List.of(mCellAgent.getNetwork()));
// The underlying capability changes do not propagate to the virtual network, but
// NetworkStatsService is informed of the new underlying interface.
@@ -7693,7 +7667,7 @@
assertFalse(nc.hasTransport(TRANSPORT_WIFI));
assertFalse(nc.hasCapability(NET_CAPABILITY_NOT_ROAMING));
final List<Network> vcnWifiAndCell = List.of(vcn.getNetwork(),
- mWiFiNetworkAgent.getNetwork(), mCellNetworkAgent.getNetwork());
+ mWiFiAgent.getNetwork(), mCellAgent.getNetwork());
expectNotifyNetworkStatus(vcnWifiAndCell, onlyVcn, vcnIface, ownerUid, vcnIface,
List.of(MOBILE_IFNAME));
}
@@ -7702,7 +7676,7 @@
public void testBasicDnsConfigurationPushed() throws Exception {
setPrivateDnsSettings(PRIVATE_DNS_MODE_OPPORTUNISTIC, "ignored.example.com");
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
waitForIdle();
verify(mMockDnsResolver, never()).setResolverConfiguration(any());
verifyNoMoreInteractions(mMockDnsResolver);
@@ -7718,18 +7692,17 @@
cellLp.addLinkAddress(new LinkAddress("2001:db8:1::1/64"));
cellLp.addRoute(new RouteInfo((IpPrefix) null, InetAddress.getByName("2001:db8:1::1"),
MOBILE_IFNAME));
- mCellNetworkAgent.sendLinkProperties(cellLp);
- mCellNetworkAgent.connect(false);
+ mCellAgent.sendLinkProperties(cellLp);
+ mCellAgent.connect(false);
waitForIdle();
- verify(mMockDnsResolver, times(1)).createNetworkCache(
- eq(mCellNetworkAgent.getNetwork().netId));
+ verify(mMockDnsResolver, times(1)).createNetworkCache(eq(mCellAgent.getNetwork().netId));
// CS tells dnsresolver about the empty DNS config for this network.
verify(mMockDnsResolver, atLeastOnce()).setResolverConfiguration(any());
reset(mMockDnsResolver);
cellLp.addDnsServer(InetAddress.getByName("2001:db8::1"));
- mCellNetworkAgent.sendLinkProperties(cellLp);
+ mCellAgent.sendLinkProperties(cellLp);
waitForIdle();
verify(mMockDnsResolver, atLeastOnce()).setResolverConfiguration(
mResolverParamsParcelCaptor.capture());
@@ -7741,7 +7714,7 @@
reset(mMockDnsResolver);
cellLp.addDnsServer(InetAddress.getByName("192.0.2.1"));
- mCellNetworkAgent.sendLinkProperties(cellLp);
+ mCellAgent.sendLinkProperties(cellLp);
waitForIdle();
verify(mMockDnsResolver, atLeastOnce()).setResolverConfiguration(
mResolverParamsParcelCaptor.capture());
@@ -7759,7 +7732,7 @@
final String TLS_SERVER6 = "2001:db8:53::53";
final InetAddress[] TLS_IPS = new InetAddress[]{ InetAddress.getByName(TLS_SERVER6) };
final String[] TLS_SERVERS = new String[]{ TLS_SERVER6 };
- mCellNetworkAgent.mNmCallbacks.notifyPrivateDnsConfigResolved(
+ mCellAgent.mNmCallbacks.notifyPrivateDnsConfigResolved(
new PrivateDnsConfig(TLS_SPECIFIER, TLS_IPS).toParcel());
waitForIdle();
@@ -7780,11 +7753,10 @@
final TestNetworkCallback callback = new TestNetworkCallback();
mCm.registerNetworkCallback(request, callback);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- verify(mMockDnsResolver, times(1)).createNetworkCache(
- eq(mWiFiNetworkAgent.getNetwork().netId));
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ verify(mMockDnsResolver, times(1)).createNetworkCache(eq(mWiFiAgent.getNetwork().netId));
verify(mMockDnsResolver, times(2)).setResolverConfiguration(
mResolverParamsParcelCaptor.capture());
final ResolverParamsParcel resolverParams = mResolverParamsParcelCaptor.getValue();
@@ -7800,31 +7772,31 @@
TestNetworkCallback callback = new TestNetworkCallback();
mCm.registerNetworkCallback(request, callback);
// Bring up wifi.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
// Private DNS resolution failed, checking if the notification will be shown or not.
- mWiFiNetworkAgent.setNetworkInvalid(true /* invalidBecauseOfPrivateDns */);
- mWiFiNetworkAgent.mNetworkMonitor.forceReevaluation(Process.myUid());
+ mWiFiAgent.setNetworkInvalid(true /* invalidBecauseOfPrivateDns */);
+ mWiFiAgent.mNetworkMonitor.forceReevaluation(Process.myUid());
waitForIdle();
// If network validation failed, NetworkMonitor will re-evaluate the network.
// ConnectivityService should filter the redundant notification. This part is trying to
// simulate that situation and check if ConnectivityService could filter that case.
- mWiFiNetworkAgent.mNetworkMonitor.forceReevaluation(Process.myUid());
+ mWiFiAgent.mNetworkMonitor.forceReevaluation(Process.myUid());
waitForIdle();
verify(mNotificationManager, timeout(TIMEOUT_MS).times(1)).notify(anyString(),
eq(NotificationType.PRIVATE_DNS_BROKEN.eventId), any());
// If private DNS resolution successful, the PRIVATE_DNS_BROKEN notification shouldn't be
// shown.
- mWiFiNetworkAgent.setNetworkValid(true /* privateDnsProbeSent */);
- mWiFiNetworkAgent.mNetworkMonitor.forceReevaluation(Process.myUid());
+ mWiFiAgent.setNetworkValid(true /* privateDnsProbeSent */);
+ mWiFiAgent.mNetworkMonitor.forceReevaluation(Process.myUid());
waitForIdle();
verify(mNotificationManager, timeout(TIMEOUT_MS).times(1)).cancel(anyString(),
eq(NotificationType.PRIVATE_DNS_BROKEN.eventId));
// If private DNS resolution failed again, the PRIVATE_DNS_BROKEN notification should be
// shown again.
- mWiFiNetworkAgent.setNetworkInvalid(true /* invalidBecauseOfPrivateDns */);
- mWiFiNetworkAgent.mNetworkMonitor.forceReevaluation(Process.myUid());
+ mWiFiAgent.setNetworkInvalid(true /* invalidBecauseOfPrivateDns */);
+ mWiFiAgent.mNetworkMonitor.forceReevaluation(Process.myUid());
waitForIdle();
verify(mNotificationManager, timeout(TIMEOUT_MS).times(2)).notify(anyString(),
eq(NotificationType.PRIVATE_DNS_BROKEN.eventId), any());
@@ -7840,7 +7812,7 @@
.addTransportType(TRANSPORT_CELLULAR).build();
mCm.requestNetwork(cellRequest, cellNetworkCallback);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
waitForIdle();
// CS tells netd about the empty DNS config for this network.
verify(mMockDnsResolver, never()).setResolverConfiguration(any());
@@ -7860,11 +7832,10 @@
cellLp.addDnsServer(InetAddress.getByName("2001:db8::1"));
cellLp.addDnsServer(InetAddress.getByName("192.0.2.1"));
- mCellNetworkAgent.sendLinkProperties(cellLp);
- mCellNetworkAgent.connect(false);
+ mCellAgent.sendLinkProperties(cellLp);
+ mCellAgent.connect(false);
waitForIdle();
- verify(mMockDnsResolver, times(1)).createNetworkCache(
- eq(mCellNetworkAgent.getNetwork().netId));
+ verify(mMockDnsResolver, times(1)).createNetworkCache(eq(mCellAgent.getNetwork().netId));
verify(mMockDnsResolver, atLeastOnce()).setResolverConfiguration(
mResolverParamsParcelCaptor.capture());
ResolverParamsParcel resolvrParams = mResolverParamsParcelCaptor.getValue();
@@ -7876,11 +7847,11 @@
assertTrue(new ArraySet<>(resolvrParams.tlsServers).containsAll(
asList("2001:db8::1", "192.0.2.1")));
reset(mMockDnsResolver);
- cellNetworkCallback.expect(AVAILABLE, mCellNetworkAgent);
- cellNetworkCallback.expect(NETWORK_CAPS_UPDATED, mCellNetworkAgent);
+ cellNetworkCallback.expect(AVAILABLE, mCellAgent);
+ cellNetworkCallback.expect(NETWORK_CAPS_UPDATED, mCellAgent);
CallbackEntry.LinkPropertiesChanged cbi = cellNetworkCallback.expect(
- LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
- cellNetworkCallback.expect(BLOCKED_STATUS, mCellNetworkAgent);
+ LINK_PROPERTIES_CHANGED, mCellAgent);
+ cellNetworkCallback.expect(BLOCKED_STATUS, mCellAgent);
cellNetworkCallback.assertNoCallback();
assertFalse(cbi.getLp().isPrivateDnsActive());
assertNull(cbi.getLp().getPrivateDnsServerName());
@@ -7911,7 +7882,7 @@
setPrivateDnsSettings(PRIVATE_DNS_MODE_PROVIDER_HOSTNAME, "strict.example.com");
// Can't test dns configuration for strict mode without properly mocking
// out the DNS lookups, but can test that LinkProperties is updated.
- cbi = cellNetworkCallback.expect(LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
+ cbi = cellNetworkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
cellNetworkCallback.assertNoCallback();
assertTrue(cbi.getLp().isPrivateDnsActive());
assertEquals("strict.example.com", cbi.getLp().getPrivateDnsServerName());
@@ -7937,17 +7908,17 @@
.addTransportType(TRANSPORT_CELLULAR).build();
mCm.requestNetwork(cellRequest, cellNetworkCallback);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
waitForIdle();
LinkProperties lp = new LinkProperties();
- mCellNetworkAgent.sendLinkProperties(lp);
- mCellNetworkAgent.connect(false);
+ mCellAgent.sendLinkProperties(lp);
+ mCellAgent.connect(false);
waitForIdle();
- cellNetworkCallback.expect(AVAILABLE, mCellNetworkAgent);
- cellNetworkCallback.expect(NETWORK_CAPS_UPDATED, mCellNetworkAgent);
+ cellNetworkCallback.expect(AVAILABLE, mCellAgent);
+ cellNetworkCallback.expect(NETWORK_CAPS_UPDATED, mCellAgent);
CallbackEntry.LinkPropertiesChanged cbi = cellNetworkCallback.expect(
- LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
- cellNetworkCallback.expect(BLOCKED_STATUS, mCellNetworkAgent);
+ LINK_PROPERTIES_CHANGED, mCellAgent);
+ cellNetworkCallback.expect(BLOCKED_STATUS, mCellAgent);
cellNetworkCallback.assertNoCallback();
assertFalse(cbi.getLp().isPrivateDnsActive());
assertNull(cbi.getLp().getPrivateDnsServerName());
@@ -7957,15 +7928,15 @@
// Send a validation event for a server that is not part of the current
// resolver config. The validation event should be ignored.
mService.mResolverUnsolEventCallback.onPrivateDnsValidationEvent(
- makePrivateDnsValidationEvent(mCellNetworkAgent.getNetwork().netId, "",
+ makePrivateDnsValidationEvent(mCellAgent.getNetwork().netId, "",
"145.100.185.18", VALIDATION_RESULT_SUCCESS));
cellNetworkCallback.assertNoCallback();
// Add a dns server to the LinkProperties.
LinkProperties lp2 = new LinkProperties(lp);
lp2.addDnsServer(InetAddress.getByName("145.100.185.16"));
- mCellNetworkAgent.sendLinkProperties(lp2);
- cbi = cellNetworkCallback.expect(LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
+ mCellAgent.sendLinkProperties(lp2);
+ cbi = cellNetworkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
cellNetworkCallback.assertNoCallback();
assertFalse(cbi.getLp().isPrivateDnsActive());
assertNull(cbi.getLp().getPrivateDnsServerName());
@@ -7975,13 +7946,13 @@
// Send a validation event containing a hostname that is not part of
// the current resolver config. The validation event should be ignored.
mService.mResolverUnsolEventCallback.onPrivateDnsValidationEvent(
- makePrivateDnsValidationEvent(mCellNetworkAgent.getNetwork().netId,
+ makePrivateDnsValidationEvent(mCellAgent.getNetwork().netId,
"145.100.185.16", "hostname", VALIDATION_RESULT_SUCCESS));
cellNetworkCallback.assertNoCallback();
// Send a validation event where validation failed.
mService.mResolverUnsolEventCallback.onPrivateDnsValidationEvent(
- makePrivateDnsValidationEvent(mCellNetworkAgent.getNetwork().netId,
+ makePrivateDnsValidationEvent(mCellAgent.getNetwork().netId,
"145.100.185.16", "", VALIDATION_RESULT_FAILURE));
cellNetworkCallback.assertNoCallback();
@@ -7989,9 +7960,9 @@
// the current resolver config. A LinkProperties callback with updated
// private dns fields should be sent.
mService.mResolverUnsolEventCallback.onPrivateDnsValidationEvent(
- makePrivateDnsValidationEvent(mCellNetworkAgent.getNetwork().netId,
+ makePrivateDnsValidationEvent(mCellAgent.getNetwork().netId,
"145.100.185.16", "", VALIDATION_RESULT_SUCCESS));
- cbi = cellNetworkCallback.expect(LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
+ cbi = cellNetworkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
cellNetworkCallback.assertNoCallback();
assertTrue(cbi.getLp().isPrivateDnsActive());
assertNull(cbi.getLp().getPrivateDnsServerName());
@@ -8001,8 +7972,8 @@
// the network agent sends unrelated changes.
LinkProperties lp3 = new LinkProperties(lp2);
lp3.setMtu(1300);
- mCellNetworkAgent.sendLinkProperties(lp3);
- cbi = cellNetworkCallback.expect(LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
+ mCellAgent.sendLinkProperties(lp3);
+ cbi = cellNetworkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
cellNetworkCallback.assertNoCallback();
assertTrue(cbi.getLp().isPrivateDnsActive());
assertNull(cbi.getLp().getPrivateDnsServerName());
@@ -8013,8 +7984,8 @@
// fields in LinkProperties.
LinkProperties lp4 = new LinkProperties(lp3);
lp4.removeDnsServer(InetAddress.getByName("145.100.185.16"));
- mCellNetworkAgent.sendLinkProperties(lp4);
- cbi = cellNetworkCallback.expect(LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
+ mCellAgent.sendLinkProperties(lp4);
+ cbi = cellNetworkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
cellNetworkCallback.assertNoCallback();
assertFalse(cbi.getLp().isPrivateDnsActive());
assertNull(cbi.getLp().getPrivateDnsServerName());
@@ -8049,10 +8020,10 @@
@Test
public void testApplyUnderlyingCapabilities() throws Exception {
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mCellNetworkAgent.connect(false /* validated */);
- mWiFiNetworkAgent.connect(false /* validated */);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mCellAgent.connect(false /* validated */);
+ mWiFiAgent.connect(false /* validated */);
final NetworkCapabilities cellNc = new NetworkCapabilities()
.addTransportType(TRANSPORT_CELLULAR)
@@ -8069,12 +8040,12 @@
.addCapability(NET_CAPABILITY_NOT_SUSPENDED)
.addCapability(NET_CAPABILITY_NOT_VCN_MANAGED)
.setLinkUpstreamBandwidthKbps(20);
- mCellNetworkAgent.setNetworkCapabilities(cellNc, true /* sendToConnectivityService */);
- mWiFiNetworkAgent.setNetworkCapabilities(wifiNc, true /* sendToConnectivityService */);
+ mCellAgent.setNetworkCapabilities(cellNc, true /* sendToConnectivityService */);
+ mWiFiAgent.setNetworkCapabilities(wifiNc, true /* sendToConnectivityService */);
waitForIdle();
- final Network mobile = mCellNetworkAgent.getNetwork();
- final Network wifi = mWiFiNetworkAgent.getNetwork();
+ final Network mobile = mCellAgent.getNetwork();
+ final Network wifi = mWiFiAgent.getNetwork();
final NetworkCapabilities initialCaps = new NetworkCapabilities();
initialCaps.addTransportType(TRANSPORT_VPN);
@@ -8228,9 +8199,9 @@
// Make that underlying network connect, and expect to see its capabilities immediately
// reflected in the VPN's capabilities.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- assertEquals(wifiNetwork, mWiFiNetworkAgent.getNetwork());
- mWiFiNetworkAgent.connect(false);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ assertEquals(wifiNetwork, mWiFiAgent.getNetwork());
+ mWiFiAgent.connect(false);
// TODO: the callback for the VPN happens before any callbacks are called for the wifi
// network that has just connected. There appear to be two issues here:
// 1. The VPN code will accept an underlying network as soon as getNetworkCapabilities()
@@ -8247,15 +8218,15 @@
// it.
underlyingNetwork.add(wifiNetwork);
assertEquals(underlyingNetwork, vpnNc2.getUnderlyingNetworks());
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
assertTrue(mCm.getNetworkCapabilities(mMockVpn.getNetwork())
.hasTransport(TRANSPORT_VPN));
assertTrue(mCm.getNetworkCapabilities(mMockVpn.getNetwork())
.hasTransport(TRANSPORT_WIFI));
// Disconnect the network, and expect to see the VPN capabilities change accordingly.
- mWiFiNetworkAgent.disconnect();
- callback.expect(LOST, mWiFiNetworkAgent);
+ mWiFiAgent.disconnect();
+ callback.expect(LOST, mWiFiAgent);
callback.expectCapabilitiesThat(mMockVpn, (nc) ->
nc.getTransportTypes().length == 1 && nc.hasTransport(TRANSPORT_VPN));
@@ -8281,8 +8252,8 @@
callback.expectAvailableCallbacksUnvalidated(mMockVpn);
// Connect cellular data.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(false /* validated */);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(false /* validated */);
callback.expectCapabilitiesThat(mMockVpn,
nc -> nc.hasCapability(NET_CAPABILITY_NOT_SUSPENDED)
&& nc.hasTransport(TRANSPORT_CELLULAR));
@@ -8297,7 +8268,7 @@
assertGetNetworkInfoOfGetActiveNetworkIsConnected(true);
// Suspend the cellular network and expect the VPN to be suspended.
- mCellNetworkAgent.suspend();
+ mCellAgent.suspend();
callback.expectCapabilitiesThat(mMockVpn,
nc -> !nc.hasCapability(NET_CAPABILITY_NOT_SUSPENDED)
&& nc.hasTransport(TRANSPORT_CELLULAR));
@@ -8314,8 +8285,8 @@
assertGetNetworkInfoOfGetActiveNetworkIsConnected(false);
// Switch to another network. The VPN should no longer be suspended.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false /* validated */);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false /* validated */);
callback.expectCapabilitiesThat(mMockVpn,
nc -> nc.hasCapability(NET_CAPABILITY_NOT_SUSPENDED)
&& nc.hasTransport(TRANSPORT_WIFI));
@@ -8331,9 +8302,9 @@
assertGetNetworkInfoOfGetActiveNetworkIsConnected(true);
// Unsuspend cellular and then switch back to it. The VPN remains not suspended.
- mCellNetworkAgent.resume();
+ mCellAgent.resume();
callback.assertNoCallback();
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
callback.expectCapabilitiesThat(mMockVpn,
nc -> nc.hasCapability(NET_CAPABILITY_NOT_SUSPENDED)
&& nc.hasTransport(TRANSPORT_CELLULAR));
@@ -8352,7 +8323,7 @@
assertGetNetworkInfoOfGetActiveNetworkIsConnected(true);
// Suspend cellular and expect no connectivity.
- mCellNetworkAgent.suspend();
+ mCellAgent.suspend();
callback.expectCapabilitiesThat(mMockVpn,
nc -> !nc.hasCapability(NET_CAPABILITY_NOT_SUSPENDED)
&& nc.hasTransport(TRANSPORT_CELLULAR));
@@ -8368,7 +8339,7 @@
assertGetNetworkInfoOfGetActiveNetworkIsConnected(false);
// Resume cellular and expect that connectivity comes back.
- mCellNetworkAgent.resume();
+ mCellAgent.resume();
callback.expectCapabilitiesThat(mMockVpn,
nc -> nc.hasCapability(NET_CAPABILITY_NOT_SUSPENDED)
&& nc.hasTransport(TRANSPORT_CELLULAR));
@@ -8411,14 +8382,14 @@
new Handler(ConnectivityThread.getInstanceLooper()));
defaultCallback.assertNoCallback();
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false);
- genericNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- genericNotVpnNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- wifiNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- defaultCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- systemDefaultCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ genericNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ genericNotVpnNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ wifiNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ defaultCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ systemDefaultCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
vpnNetworkCallback.assertNoCallback();
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
@@ -8444,8 +8415,7 @@
defaultCallback.expectAvailableThenValidatedCallbacks(mMockVpn);
systemDefaultCallback.assertNoCallback();
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
- assertEquals(mWiFiNetworkAgent.getNetwork(),
- systemDefaultCallback.getLastAvailableNetwork());
+ assertEquals(mWiFiAgent.getNetwork(), systemDefaultCallback.getLastAvailableNetwork());
ranges.clear();
mMockVpn.setUids(ranges);
@@ -8476,14 +8446,14 @@
defaultCallback.expect(NETWORK_CAPS_UPDATED, mMockVpn);
systemDefaultCallback.assertNoCallback();
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
- genericNetworkCallback.expect(LOST, mWiFiNetworkAgent);
- genericNotVpnNetworkCallback.expect(LOST, mWiFiNetworkAgent);
- wifiNetworkCallback.expect(LOST, mWiFiNetworkAgent);
+ genericNetworkCallback.expect(LOST, mWiFiAgent);
+ genericNotVpnNetworkCallback.expect(LOST, mWiFiAgent);
+ wifiNetworkCallback.expect(LOST, mWiFiAgent);
vpnNetworkCallback.assertNoCallback();
defaultCallback.assertNoCallback();
- systemDefaultCallback.expect(LOST, mWiFiNetworkAgent);
+ systemDefaultCallback.expect(LOST, mWiFiAgent);
mMockVpn.disconnect();
@@ -8509,10 +8479,10 @@
final TestNetworkCallback defaultCallback = new TestNetworkCallback();
mCm.registerDefaultNetworkCallback(defaultCallback);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
- defaultCallback.expectAvailableThenValidatedCallbacks(mWiFiNetworkAgent);
+ defaultCallback.expectAvailableThenValidatedCallbacks(mWiFiAgent);
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
mMockVpn.establishForMyUid(true /* validated */, false /* hasInternet */,
@@ -8535,10 +8505,10 @@
final TestNetworkCallback defaultCallback = new TestNetworkCallback();
mCm.registerDefaultNetworkCallback(defaultCallback);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
- defaultCallback.expectAvailableThenValidatedCallbacks(mWiFiNetworkAgent);
+ defaultCallback.expectAvailableThenValidatedCallbacks(mWiFiAgent);
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
mMockVpn.establishForMyUid(true /* validated */, true /* hasInternet */,
@@ -8550,7 +8520,7 @@
mMockVpn.disconnect();
defaultCallback.expect(LOST, mMockVpn);
- defaultCallback.expectAvailableCallbacksValidated(mWiFiNetworkAgent);
+ defaultCallback.expectAvailableCallbacksValidated(mWiFiAgent);
mCm.unregisterNetworkCallback(defaultCallback);
}
@@ -8561,9 +8531,9 @@
mCm.registerDefaultNetworkCallback(callback);
// Bring up Ethernet.
- mEthernetNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_ETHERNET);
- mEthernetNetworkAgent.connect(true);
- callback.expectAvailableThenValidatedCallbacks(mEthernetNetworkAgent);
+ mEthernetAgent = new TestNetworkAgentWrapper(TRANSPORT_ETHERNET);
+ mEthernetAgent.connect(true);
+ callback.expectAvailableThenValidatedCallbacks(mEthernetAgent);
callback.assertNoCallback();
// Bring up a VPN that has the INTERNET capability, initially unvalidated.
@@ -8599,7 +8569,7 @@
mMockVpn.disconnect();
callback.expect(LOST, mMockVpn);
- callback.expectAvailableCallbacksValidated(mEthernetNetworkAgent);
+ callback.expectAvailableCallbacksValidated(mEthernetAgent);
}
@Test
@@ -8616,9 +8586,9 @@
// Connect cell. It will become the default network, and in the absence of setting
// underlying networks explicitly it will become the sole underlying network for the vpn.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.addCapability(NET_CAPABILITY_NOT_SUSPENDED);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.addCapability(NET_CAPABILITY_NOT_SUSPENDED);
+ mCellAgent.connect(true);
mMockVpn.establishForMyUid(true /* validated */, false /* hasInternet */,
false /* privateDnsProbeSent */);
@@ -8683,38 +8653,36 @@
assertDefaultNetworkCapabilities(userId /* no networks */);
// Connect cell and use it as an underlying network.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.addCapability(NET_CAPABILITY_NOT_SUSPENDED);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.addCapability(NET_CAPABILITY_NOT_SUSPENDED);
+ mCellAgent.connect(true);
- mMockVpn.setUnderlyingNetworks(
- new Network[] { mCellNetworkAgent.getNetwork() });
+ mMockVpn.setUnderlyingNetworks(new Network[] { mCellAgent.getNetwork() });
vpnNetworkCallback.expectCapabilitiesThat(mMockVpn,
(caps) -> caps.hasTransport(TRANSPORT_VPN)
&& caps.hasTransport(TRANSPORT_CELLULAR) && !caps.hasTransport(TRANSPORT_WIFI)
&& !caps.hasCapability(NET_CAPABILITY_NOT_METERED)
&& caps.hasCapability(NET_CAPABILITY_NOT_SUSPENDED));
- assertDefaultNetworkCapabilities(userId, mCellNetworkAgent);
+ assertDefaultNetworkCapabilities(userId, mCellAgent);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
- mWiFiNetworkAgent.addCapability(NET_CAPABILITY_NOT_SUSPENDED);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.addCapability(NET_CAPABILITY_NOT_METERED);
+ mWiFiAgent.addCapability(NET_CAPABILITY_NOT_SUSPENDED);
+ mWiFiAgent.connect(true);
mMockVpn.setUnderlyingNetworks(
- new Network[] { mCellNetworkAgent.getNetwork(), mWiFiNetworkAgent.getNetwork() });
+ new Network[] { mCellAgent.getNetwork(), mWiFiAgent.getNetwork() });
vpnNetworkCallback.expectCapabilitiesThat(mMockVpn,
(caps) -> caps.hasTransport(TRANSPORT_VPN)
&& caps.hasTransport(TRANSPORT_CELLULAR) && caps.hasTransport(TRANSPORT_WIFI)
&& !caps.hasCapability(NET_CAPABILITY_NOT_METERED)
&& caps.hasCapability(NET_CAPABILITY_NOT_SUSPENDED));
- assertDefaultNetworkCapabilities(userId, mCellNetworkAgent, mWiFiNetworkAgent);
+ assertDefaultNetworkCapabilities(userId, mCellAgent, mWiFiAgent);
// Don't disconnect, but note the VPN is not using wifi any more.
- mMockVpn.setUnderlyingNetworks(
- new Network[] { mCellNetworkAgent.getNetwork() });
+ mMockVpn.setUnderlyingNetworks(new Network[] { mCellAgent.getNetwork() });
vpnNetworkCallback.expectCapabilitiesThat(mMockVpn,
(caps) -> caps.hasTransport(TRANSPORT_VPN)
@@ -8723,10 +8691,10 @@
&& caps.hasCapability(NET_CAPABILITY_NOT_SUSPENDED));
// The return value of getDefaultNetworkCapabilitiesForUser always includes the default
// network (wifi) as well as the underlying networks (cell).
- assertDefaultNetworkCapabilities(userId, mCellNetworkAgent, mWiFiNetworkAgent);
+ assertDefaultNetworkCapabilities(userId, mCellAgent, mWiFiAgent);
// Remove NOT_SUSPENDED from the only network and observe VPN is now suspended.
- mCellNetworkAgent.removeCapability(NET_CAPABILITY_NOT_SUSPENDED);
+ mCellAgent.removeCapability(NET_CAPABILITY_NOT_SUSPENDED);
vpnNetworkCallback.expectCapabilitiesThat(mMockVpn,
(caps) -> caps.hasTransport(TRANSPORT_VPN)
&& caps.hasTransport(TRANSPORT_CELLULAR) && !caps.hasTransport(TRANSPORT_WIFI)
@@ -8735,7 +8703,7 @@
vpnNetworkCallback.expect(SUSPENDED, mMockVpn);
// Add NOT_SUSPENDED again and observe VPN is no longer suspended.
- mCellNetworkAgent.addCapability(NET_CAPABILITY_NOT_SUSPENDED);
+ mCellAgent.addCapability(NET_CAPABILITY_NOT_SUSPENDED);
vpnNetworkCallback.expectCapabilitiesThat(mMockVpn,
(caps) -> caps.hasTransport(TRANSPORT_VPN)
&& caps.hasTransport(TRANSPORT_CELLULAR) && !caps.hasTransport(TRANSPORT_WIFI)
@@ -8744,45 +8712,43 @@
vpnNetworkCallback.expect(RESUMED, mMockVpn);
// Use Wifi but not cell. Note the VPN is now unmetered and not suspended.
- mMockVpn.setUnderlyingNetworks(
- new Network[] { mWiFiNetworkAgent.getNetwork() });
+ mMockVpn.setUnderlyingNetworks(new Network[] { mWiFiAgent.getNetwork() });
vpnNetworkCallback.expectCapabilitiesThat(mMockVpn,
(caps) -> caps.hasTransport(TRANSPORT_VPN)
&& !caps.hasTransport(TRANSPORT_CELLULAR) && caps.hasTransport(TRANSPORT_WIFI)
&& caps.hasCapability(NET_CAPABILITY_NOT_METERED)
&& caps.hasCapability(NET_CAPABILITY_NOT_SUSPENDED));
- assertDefaultNetworkCapabilities(userId, mWiFiNetworkAgent);
+ assertDefaultNetworkCapabilities(userId, mWiFiAgent);
// Use both again.
mMockVpn.setUnderlyingNetworks(
- new Network[] { mCellNetworkAgent.getNetwork(), mWiFiNetworkAgent.getNetwork() });
+ new Network[] { mCellAgent.getNetwork(), mWiFiAgent.getNetwork() });
vpnNetworkCallback.expectCapabilitiesThat(mMockVpn,
(caps) -> caps.hasTransport(TRANSPORT_VPN)
&& caps.hasTransport(TRANSPORT_CELLULAR) && caps.hasTransport(TRANSPORT_WIFI)
&& !caps.hasCapability(NET_CAPABILITY_NOT_METERED)
&& caps.hasCapability(NET_CAPABILITY_NOT_SUSPENDED));
- assertDefaultNetworkCapabilities(userId, mCellNetworkAgent, mWiFiNetworkAgent);
+ assertDefaultNetworkCapabilities(userId, mCellAgent, mWiFiAgent);
// Cell is suspended again. As WiFi is not, this should not cause a callback.
- mCellNetworkAgent.removeCapability(NET_CAPABILITY_NOT_SUSPENDED);
+ mCellAgent.removeCapability(NET_CAPABILITY_NOT_SUSPENDED);
vpnNetworkCallback.assertNoCallback();
// Stop using WiFi. The VPN is suspended again.
- mMockVpn.setUnderlyingNetworks(
- new Network[] { mCellNetworkAgent.getNetwork() });
+ mMockVpn.setUnderlyingNetworks(new Network[] { mCellAgent.getNetwork() });
vpnNetworkCallback.expectCapabilitiesThat(mMockVpn,
(caps) -> caps.hasTransport(TRANSPORT_VPN)
&& caps.hasTransport(TRANSPORT_CELLULAR)
&& !caps.hasCapability(NET_CAPABILITY_NOT_METERED)
&& !caps.hasCapability(NET_CAPABILITY_NOT_SUSPENDED));
vpnNetworkCallback.expect(SUSPENDED, mMockVpn);
- assertDefaultNetworkCapabilities(userId, mCellNetworkAgent, mWiFiNetworkAgent);
+ assertDefaultNetworkCapabilities(userId, mCellAgent, mWiFiAgent);
// Use both again.
mMockVpn.setUnderlyingNetworks(
- new Network[] { mCellNetworkAgent.getNetwork(), mWiFiNetworkAgent.getNetwork() });
+ new Network[] { mCellAgent.getNetwork(), mWiFiAgent.getNetwork() });
vpnNetworkCallback.expectCapabilitiesThat(mMockVpn,
(caps) -> caps.hasTransport(TRANSPORT_VPN)
@@ -8790,19 +8756,19 @@
&& !caps.hasCapability(NET_CAPABILITY_NOT_METERED)
&& caps.hasCapability(NET_CAPABILITY_NOT_SUSPENDED));
vpnNetworkCallback.expect(RESUMED, mMockVpn);
- assertDefaultNetworkCapabilities(userId, mCellNetworkAgent, mWiFiNetworkAgent);
+ assertDefaultNetworkCapabilities(userId, mCellAgent, mWiFiAgent);
// Disconnect cell. Receive update without even removing the dead network from the
// underlying networks – it's dead anyway. Not metered any more.
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
vpnNetworkCallback.expectCapabilitiesThat(mMockVpn,
(caps) -> caps.hasTransport(TRANSPORT_VPN)
&& !caps.hasTransport(TRANSPORT_CELLULAR) && caps.hasTransport(TRANSPORT_WIFI)
&& caps.hasCapability(NET_CAPABILITY_NOT_METERED));
- assertDefaultNetworkCapabilities(userId, mWiFiNetworkAgent);
+ assertDefaultNetworkCapabilities(userId, mWiFiAgent);
// Disconnect wifi too. No underlying networks means this is now metered.
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
vpnNetworkCallback.expectCapabilitiesThat(mMockVpn,
(caps) -> caps.hasTransport(TRANSPORT_VPN)
&& !caps.hasTransport(TRANSPORT_CELLULAR) && !caps.hasTransport(TRANSPORT_WIFI)
@@ -8844,8 +8810,8 @@
assertVpnTransportInfo(nc, VpnManager.TYPE_VPN_SERVICE);
// Connect to Cell; Cell is the default network.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
vpnNetworkCallback.expectCapabilitiesThat(mMockVpn,
(caps) -> caps.hasTransport(TRANSPORT_VPN)
@@ -8853,9 +8819,9 @@
&& !caps.hasCapability(NET_CAPABILITY_NOT_METERED));
// Connect to WiFi; WiFi is the new default.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.addCapability(NET_CAPABILITY_NOT_METERED);
+ mWiFiAgent.connect(true);
vpnNetworkCallback.expectCapabilitiesThat(mMockVpn,
(caps) -> caps.hasTransport(TRANSPORT_VPN)
@@ -8864,10 +8830,10 @@
// Disconnect Cell. The default network did not change, so there shouldn't be any changes in
// the capabilities.
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
// Disconnect wifi too. Now we have no default network.
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
vpnNetworkCallback.expectCapabilitiesThat(mMockVpn,
(caps) -> caps.hasTransport(TRANSPORT_VPN)
@@ -8901,13 +8867,13 @@
assertVpnTransportInfo(nc, VpnManager.TYPE_VPN_SERVICE);
// Set an underlying network and expect to see the VPN transports change.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
callback.expectCapabilitiesThat(mMockVpn, (caps)
-> caps.hasTransport(TRANSPORT_VPN)
&& caps.hasTransport(TRANSPORT_WIFI));
- callback.expectCapabilitiesThat(mWiFiNetworkAgent, (caps)
+ callback.expectCapabilitiesThat(mWiFiAgent, (caps)
-> caps.hasCapability(NET_CAPABILITY_VALIDATED));
doReturn(UserHandle.getUid(RESTRICTED_USER, VPN_UID)).when(mPackageManager)
@@ -8929,8 +8895,8 @@
&& caps.hasTransport(TRANSPORT_WIFI));
// Change the VPN's capabilities somehow (specifically, disconnect wifi).
- mWiFiNetworkAgent.disconnect();
- callback.expect(LOST, mWiFiNetworkAgent);
+ mWiFiAgent.disconnect();
+ callback.expect(LOST, mWiFiAgent);
callback.expectCapabilitiesThat(mMockVpn, (caps)
-> caps.getUids().size() == 2
&& caps.getUids().contains(singleUidRange)
@@ -8970,8 +8936,8 @@
final int uid = Process.myUid();
// Connect wifi and check that UIDs in the main and restricted profiles have network access.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true /* validated */);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true /* validated */);
final int restrictedUid = UserHandle.getUid(RESTRICTED_USER, 42 /* appId */);
assertNotNull(mCm.getActiveNetworkForUid(uid));
assertNotNull(mCm.getActiveNetworkForUid(restrictedUid));
@@ -9020,9 +8986,9 @@
public void testIsActiveNetworkMeteredOverWifi() throws Exception {
// Returns true by default when no network is available.
assertTrue(mCm.isActiveNetworkMetered());
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.addCapability(NET_CAPABILITY_NOT_METERED);
+ mWiFiAgent.connect(true);
waitForIdle();
assertFalse(mCm.isActiveNetworkMetered());
@@ -9032,9 +8998,9 @@
public void testIsActiveNetworkMeteredOverCell() throws Exception {
// Returns true by default when no network is available.
assertTrue(mCm.isActiveNetworkMetered());
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.removeCapability(NET_CAPABILITY_NOT_METERED);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.removeCapability(NET_CAPABILITY_NOT_METERED);
+ mCellAgent.connect(true);
waitForIdle();
assertTrue(mCm.isActiveNetworkMetered());
@@ -9044,9 +9010,9 @@
public void testIsActiveNetworkMeteredOverVpnTrackingPlatformDefault() throws Exception {
// Returns true by default when no network is available.
assertTrue(mCm.isActiveNetworkMetered());
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.removeCapability(NET_CAPABILITY_NOT_METERED);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.removeCapability(NET_CAPABILITY_NOT_METERED);
+ mCellAgent.connect(true);
waitForIdle();
assertTrue(mCm.isActiveNetworkMetered());
@@ -9061,9 +9027,9 @@
assertTrue(mCm.isActiveNetworkMetered());
// Connect WiFi.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.addCapability(NET_CAPABILITY_NOT_METERED);
+ mWiFiAgent.connect(true);
waitForIdle();
// VPN should still be the active network.
assertEquals(mMockVpn.getNetwork(), mCm.getActiveNetwork());
@@ -9072,13 +9038,13 @@
assertFalse(mCm.isActiveNetworkMetered());
// Disconnecting Cell should not affect VPN's meteredness.
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
waitForIdle();
assertFalse(mCm.isActiveNetworkMetered());
// Disconnect WiFi; Now there is no platform default network.
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
waitForIdle();
// VPN without any underlying networks is treated as metered.
@@ -9091,15 +9057,15 @@
public void testIsActiveNetworkMeteredOverVpnSpecifyingUnderlyingNetworks() throws Exception {
// Returns true by default when no network is available.
assertTrue(mCm.isActiveNetworkMetered());
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.removeCapability(NET_CAPABILITY_NOT_METERED);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.removeCapability(NET_CAPABILITY_NOT_METERED);
+ mCellAgent.connect(true);
waitForIdle();
assertTrue(mCm.isActiveNetworkMetered());
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.addCapability(NET_CAPABILITY_NOT_METERED);
+ mWiFiAgent.connect(true);
waitForIdle();
assertFalse(mCm.isActiveNetworkMetered());
@@ -9110,16 +9076,14 @@
// Ensure VPN is now the active network.
assertEquals(mMockVpn.getNetwork(), mCm.getActiveNetwork());
// VPN is using Cell
- mMockVpn.setUnderlyingNetworks(
- new Network[] { mCellNetworkAgent.getNetwork() });
+ mMockVpn.setUnderlyingNetworks(new Network[] { mCellAgent.getNetwork() });
waitForIdle();
// Expect VPN to be metered.
assertTrue(mCm.isActiveNetworkMetered());
// VPN is now using WiFi
- mMockVpn.setUnderlyingNetworks(
- new Network[] { mWiFiNetworkAgent.getNetwork() });
+ mMockVpn.setUnderlyingNetworks(new Network[] { mWiFiAgent.getNetwork() });
waitForIdle();
// Expect VPN to be unmetered
@@ -9127,7 +9091,7 @@
// VPN is using Cell | WiFi.
mMockVpn.setUnderlyingNetworks(
- new Network[] { mCellNetworkAgent.getNetwork(), mWiFiNetworkAgent.getNetwork() });
+ new Network[] { mCellAgent.getNetwork(), mWiFiAgent.getNetwork() });
waitForIdle();
// Expect VPN to be metered.
@@ -9135,7 +9099,7 @@
// VPN is using WiFi | Cell.
mMockVpn.setUnderlyingNetworks(
- new Network[] { mWiFiNetworkAgent.getNetwork(), mCellNetworkAgent.getNetwork() });
+ new Network[] { mWiFiAgent.getNetwork(), mCellAgent.getNetwork() });
waitForIdle();
// Order should not matter and VPN should still be metered.
@@ -9155,9 +9119,9 @@
public void testIsActiveNetworkMeteredOverAlwaysMeteredVpn() throws Exception {
// Returns true by default when no network is available.
assertTrue(mCm.isActiveNetworkMetered());
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.addCapability(NET_CAPABILITY_NOT_METERED);
+ mWiFiAgent.connect(true);
waitForIdle();
assertFalse(mCm.isActiveNetworkMetered());
@@ -9177,8 +9141,7 @@
// VPN explicitly declares WiFi as its underlying network.
- mMockVpn.setUnderlyingNetworks(
- new Network[] { mWiFiNetworkAgent.getNetwork() });
+ mMockVpn.setUnderlyingNetworks(new Network[] { mWiFiAgent.getNetwork() });
waitForIdle();
// Doesn't really matter whether VPN declares its underlying networks explicitly.
@@ -9186,7 +9149,7 @@
// With WiFi lost, VPN is basically without any underlying networks. And in that case it is
// anyways suppose to be metered.
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
waitForIdle();
assertTrue(mCm.isActiveNetworkMetered());
@@ -9220,80 +9183,74 @@
mockUidNetworkingBlocked();
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- detailedCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent,
- BLOCKED_REASON_NONE);
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ detailedCallback.expectAvailableThenValidatedCallbacks(mCellAgent, BLOCKED_REASON_NONE);
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_MOBILE, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.CONNECTED);
- assertExtraInfoFromCmPresent(mCellNetworkAgent);
+ assertExtraInfoFromCmPresent(mCellAgent);
setBlockedReasonChanged(BLOCKED_REASON_BATTERY_SAVER);
- cellNetworkCallback.expectBlockedStatusCallback(true, mCellNetworkAgent);
- detailedCallback.expectBlockedStatusCallback(mCellNetworkAgent,
- BLOCKED_REASON_BATTERY_SAVER);
+ cellNetworkCallback.expectBlockedStatusCallback(true, mCellAgent);
+ detailedCallback.expectBlockedStatusCallback(mCellAgent, BLOCKED_REASON_BATTERY_SAVER);
assertNull(mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_MOBILE, DetailedState.BLOCKED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.BLOCKED);
- assertExtraInfoFromCmBlocked(mCellNetworkAgent);
+ assertExtraInfoFromCmBlocked(mCellAgent);
// If blocked state does not change but blocked reason does, the boolean callback is called.
// TODO: investigate de-duplicating.
setBlockedReasonChanged(BLOCKED_METERED_REASON_USER_RESTRICTED);
- cellNetworkCallback.expectBlockedStatusCallback(true, mCellNetworkAgent);
- detailedCallback.expectBlockedStatusCallback(mCellNetworkAgent,
+ cellNetworkCallback.expectBlockedStatusCallback(true, mCellAgent);
+ detailedCallback.expectBlockedStatusCallback(mCellAgent,
BLOCKED_METERED_REASON_USER_RESTRICTED);
setBlockedReasonChanged(BLOCKED_REASON_NONE);
- cellNetworkCallback.expectBlockedStatusCallback(false, mCellNetworkAgent);
- detailedCallback.expectBlockedStatusCallback(mCellNetworkAgent, BLOCKED_REASON_NONE);
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ cellNetworkCallback.expectBlockedStatusCallback(false, mCellAgent);
+ detailedCallback.expectBlockedStatusCallback(mCellAgent, BLOCKED_REASON_NONE);
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_MOBILE, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.CONNECTED);
- assertExtraInfoFromCmPresent(mCellNetworkAgent);
+ assertExtraInfoFromCmPresent(mCellAgent);
setBlockedReasonChanged(BLOCKED_METERED_REASON_DATA_SAVER);
- cellNetworkCallback.expectBlockedStatusCallback(true, mCellNetworkAgent);
- detailedCallback.expectBlockedStatusCallback(mCellNetworkAgent,
- BLOCKED_METERED_REASON_DATA_SAVER);
+ cellNetworkCallback.expectBlockedStatusCallback(true, mCellAgent);
+ detailedCallback.expectBlockedStatusCallback(mCellAgent, BLOCKED_METERED_REASON_DATA_SAVER);
assertNull(mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_MOBILE, DetailedState.BLOCKED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.BLOCKED);
- assertExtraInfoFromCmBlocked(mCellNetworkAgent);
+ assertExtraInfoFromCmBlocked(mCellAgent);
// Restrict the network based on UID rule and NOT_METERED capability change.
- mCellNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
- cellNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_NOT_METERED, mCellNetworkAgent);
- cellNetworkCallback.expectBlockedStatusCallback(false, mCellNetworkAgent);
- detailedCallback.expectCapabilitiesWith(NET_CAPABILITY_NOT_METERED, mCellNetworkAgent);
- detailedCallback.expectBlockedStatusCallback(mCellNetworkAgent, BLOCKED_REASON_NONE);
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ mCellAgent.addCapability(NET_CAPABILITY_NOT_METERED);
+ cellNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_NOT_METERED, mCellAgent);
+ cellNetworkCallback.expectBlockedStatusCallback(false, mCellAgent);
+ detailedCallback.expectCapabilitiesWith(NET_CAPABILITY_NOT_METERED, mCellAgent);
+ detailedCallback.expectBlockedStatusCallback(mCellAgent, BLOCKED_REASON_NONE);
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_MOBILE, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.CONNECTED);
- assertExtraInfoFromCmPresent(mCellNetworkAgent);
+ assertExtraInfoFromCmPresent(mCellAgent);
- mCellNetworkAgent.removeCapability(NET_CAPABILITY_NOT_METERED);
- cellNetworkCallback.expectCapabilitiesWithout(NET_CAPABILITY_NOT_METERED,
- mCellNetworkAgent);
- cellNetworkCallback.expectBlockedStatusCallback(true, mCellNetworkAgent);
- detailedCallback.expectCapabilitiesWithout(NET_CAPABILITY_NOT_METERED,
- mCellNetworkAgent);
- detailedCallback.expectBlockedStatusCallback(mCellNetworkAgent,
- BLOCKED_METERED_REASON_DATA_SAVER);
+ mCellAgent.removeCapability(NET_CAPABILITY_NOT_METERED);
+ cellNetworkCallback.expectCapabilitiesWithout(NET_CAPABILITY_NOT_METERED, mCellAgent);
+ cellNetworkCallback.expectBlockedStatusCallback(true, mCellAgent);
+ detailedCallback.expectCapabilitiesWithout(NET_CAPABILITY_NOT_METERED, mCellAgent);
+ detailedCallback.expectBlockedStatusCallback(mCellAgent, BLOCKED_METERED_REASON_DATA_SAVER);
assertNull(mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_MOBILE, DetailedState.BLOCKED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.BLOCKED);
- assertExtraInfoFromCmBlocked(mCellNetworkAgent);
+ assertExtraInfoFromCmBlocked(mCellAgent);
setBlockedReasonChanged(BLOCKED_REASON_NONE);
- cellNetworkCallback.expectBlockedStatusCallback(false, mCellNetworkAgent);
- detailedCallback.expectBlockedStatusCallback(mCellNetworkAgent, BLOCKED_REASON_NONE);
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ cellNetworkCallback.expectBlockedStatusCallback(false, mCellAgent);
+ detailedCallback.expectBlockedStatusCallback(mCellAgent, BLOCKED_REASON_NONE);
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_MOBILE, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.CONNECTED);
- assertExtraInfoFromCmPresent(mCellNetworkAgent);
+ assertExtraInfoFromCmPresent(mCellAgent);
setBlockedReasonChanged(BLOCKED_REASON_NONE);
cellNetworkCallback.assertNoCallback();
@@ -9301,30 +9258,29 @@
// Restrict background data. Networking is not blocked because the network is unmetered.
setBlockedReasonChanged(BLOCKED_METERED_REASON_DATA_SAVER);
- cellNetworkCallback.expectBlockedStatusCallback(true, mCellNetworkAgent);
- detailedCallback.expectBlockedStatusCallback(mCellNetworkAgent,
- BLOCKED_METERED_REASON_DATA_SAVER);
+ cellNetworkCallback.expectBlockedStatusCallback(true, mCellAgent);
+ detailedCallback.expectBlockedStatusCallback(mCellAgent, BLOCKED_METERED_REASON_DATA_SAVER);
assertNull(mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_MOBILE, DetailedState.BLOCKED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.BLOCKED);
- assertExtraInfoFromCmBlocked(mCellNetworkAgent);
+ assertExtraInfoFromCmBlocked(mCellAgent);
setBlockedReasonChanged(BLOCKED_METERED_REASON_DATA_SAVER);
cellNetworkCallback.assertNoCallback();
setBlockedReasonChanged(BLOCKED_REASON_NONE);
- cellNetworkCallback.expectBlockedStatusCallback(false, mCellNetworkAgent);
- detailedCallback.expectBlockedStatusCallback(mCellNetworkAgent, BLOCKED_REASON_NONE);
+ cellNetworkCallback.expectBlockedStatusCallback(false, mCellAgent);
+ detailedCallback.expectBlockedStatusCallback(mCellAgent, BLOCKED_REASON_NONE);
assertActiveNetworkInfo(TYPE_MOBILE, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.CONNECTED);
- assertExtraInfoFromCmPresent(mCellNetworkAgent);
+ assertExtraInfoFromCmPresent(mCellAgent);
setBlockedReasonChanged(BLOCKED_REASON_NONE);
cellNetworkCallback.assertNoCallback();
detailedCallback.assertNoCallback();
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_MOBILE, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.CONNECTED);
- assertExtraInfoFromCmPresent(mCellNetworkAgent);
+ assertExtraInfoFromCmPresent(mCellAgent);
mCm.unregisterNetworkCallback(cellNetworkCallback);
}
@@ -9341,34 +9297,34 @@
setBlockedReasonChanged(BLOCKED_METERED_REASON_DATA_SAVER);
defaultCallback.assertNoCallback();
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- defaultCallback.expectAvailableCallbacksUnvalidatedAndBlocked(mCellNetworkAgent);
- defaultCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ defaultCallback.expectAvailableCallbacksUnvalidatedAndBlocked(mCellAgent);
+ defaultCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mCellAgent);
// Allow to use the network after switching to NOT_METERED network.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
- mWiFiNetworkAgent.connect(true);
- defaultCallback.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.addCapability(NET_CAPABILITY_NOT_METERED);
+ mWiFiAgent.connect(true);
+ defaultCallback.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
// Switch to METERED network. Restrict the use of the network.
- mWiFiNetworkAgent.disconnect();
- defaultCallback.expect(LOST, mWiFiNetworkAgent);
- defaultCallback.expectAvailableCallbacksValidatedAndBlocked(mCellNetworkAgent);
+ mWiFiAgent.disconnect();
+ defaultCallback.expect(LOST, mWiFiAgent);
+ defaultCallback.expectAvailableCallbacksValidatedAndBlocked(mCellAgent);
// Network becomes NOT_METERED.
- mCellNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
- defaultCallback.expectCapabilitiesWith(NET_CAPABILITY_NOT_METERED, mCellNetworkAgent);
- defaultCallback.expectBlockedStatusCallback(false, mCellNetworkAgent);
+ mCellAgent.addCapability(NET_CAPABILITY_NOT_METERED);
+ defaultCallback.expectCapabilitiesWith(NET_CAPABILITY_NOT_METERED, mCellAgent);
+ defaultCallback.expectBlockedStatusCallback(false, mCellAgent);
// Verify there's no Networkcallbacks invoked after data saver on/off.
setBlockedReasonChanged(BLOCKED_METERED_REASON_DATA_SAVER);
setBlockedReasonChanged(BLOCKED_REASON_NONE);
defaultCallback.assertNoCallback();
- mCellNetworkAgent.disconnect();
- defaultCallback.expect(LOST, mCellNetworkAgent);
+ mCellAgent.disconnect();
+ defaultCallback.expect(LOST, mCellAgent);
defaultCallback.assertNoCallback();
mCm.unregisterNetworkCallback(defaultCallback);
@@ -9485,14 +9441,14 @@
expectNetworkRejectNonSecureVpn(inOrder, true, uidRangeParcels);
// Connect a network when lockdown is active, expect to see it blocked.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(false /* validated */);
- callback.expectAvailableCallbacksUnvalidatedAndBlocked(mWiFiNetworkAgent);
- defaultCallback.expectAvailableCallbacksUnvalidatedAndBlocked(mWiFiNetworkAgent);
- vpnUidCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- vpnUidDefaultCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- vpnDefaultCallbackAsUid.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(false /* validated */);
+ callback.expectAvailableCallbacksUnvalidatedAndBlocked(mWiFiAgent);
+ defaultCallback.expectAvailableCallbacksUnvalidatedAndBlocked(mWiFiAgent);
+ vpnUidCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ vpnUidDefaultCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ vpnDefaultCallbackAsUid.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
assertNull(mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_WIFI, DetailedState.BLOCKED);
// Mobile is BLOCKED even though it's not actually connected.
@@ -9501,14 +9457,14 @@
// Disable lockdown, expect to see the network unblocked.
mMockVpn.setAlwaysOnPackage(null, false /* lockdown */, allowList);
- callback.expectBlockedStatusCallback(false, mWiFiNetworkAgent);
- defaultCallback.expectBlockedStatusCallback(false, mWiFiNetworkAgent);
+ callback.expectBlockedStatusCallback(false, mWiFiAgent);
+ defaultCallback.expectBlockedStatusCallback(false, mWiFiAgent);
vpnUidCallback.assertNoCallback();
vpnUidDefaultCallback.assertNoCallback();
vpnDefaultCallbackAsUid.assertNoCallback();
expectNetworkRejectNonSecureVpn(inOrder, false, uidRangeParcels);
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_WIFI, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.DISCONNECTED);
assertNetworkInfo(TYPE_WIFI, DetailedState.CONNECTED);
@@ -9530,22 +9486,22 @@
final UidRangeParcel[] uidRangeParcelsAlsoExcludingUs = uidRangeParcelsExcludingUids(
excludedUids.toArray(new Integer[0]));
expectNetworkRejectNonSecureVpn(inOrder, true, uidRangeParcelsAlsoExcludingUs);
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_WIFI, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.DISCONNECTED);
assertNetworkInfo(TYPE_WIFI, DetailedState.CONNECTED);
// Connect a new network, expect it to be unblocked.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(false /* validated */);
- callback.expectAvailableCallbacksUnvalidated(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(false /* validated */);
+ callback.expectAvailableCallbacksUnvalidated(mCellAgent);
defaultCallback.assertNoCallback();
- vpnUidCallback.expectAvailableCallbacksUnvalidated(mCellNetworkAgent);
+ vpnUidCallback.expectAvailableCallbacksUnvalidated(mCellAgent);
vpnUidDefaultCallback.assertNoCallback();
vpnDefaultCallbackAsUid.assertNoCallback();
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_WIFI, DetailedState.CONNECTED);
// Cellular is DISCONNECTED because it's not the default and there are no requests for it.
assertNetworkInfo(TYPE_MOBILE, DetailedState.DISCONNECTED);
@@ -9560,12 +9516,12 @@
mMockVpn.setAlwaysOnPackage(ALWAYS_ON_PACKAGE, true /* lockdown */, allowList);
waitForIdle();
expectNetworkRejectNonSecureVpn(inOrder, true, uidRangeParcels);
- defaultCallback.expectBlockedStatusCallback(true, mWiFiNetworkAgent);
- assertBlockedCallbackInAnyOrder(callback, true, mWiFiNetworkAgent, mCellNetworkAgent);
+ defaultCallback.expectBlockedStatusCallback(true, mWiFiAgent);
+ assertBlockedCallbackInAnyOrder(callback, true, mWiFiAgent, mCellAgent);
vpnUidCallback.assertNoCallback();
vpnUidDefaultCallback.assertNoCallback();
vpnDefaultCallbackAsUid.assertNoCallback();
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
assertNull(mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_WIFI, DetailedState.BLOCKED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.BLOCKED);
@@ -9573,13 +9529,13 @@
// Disable lockdown. Everything is unblocked.
mMockVpn.setAlwaysOnPackage(null, false /* lockdown */, allowList);
- defaultCallback.expectBlockedStatusCallback(false, mWiFiNetworkAgent);
- assertBlockedCallbackInAnyOrder(callback, false, mWiFiNetworkAgent, mCellNetworkAgent);
+ defaultCallback.expectBlockedStatusCallback(false, mWiFiAgent);
+ assertBlockedCallbackInAnyOrder(callback, false, mWiFiAgent, mCellAgent);
vpnUidCallback.assertNoCallback();
vpnUidDefaultCallback.assertNoCallback();
vpnDefaultCallbackAsUid.assertNoCallback();
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_WIFI, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.DISCONNECTED);
assertNetworkInfo(TYPE_WIFI, DetailedState.CONNECTED);
@@ -9593,8 +9549,8 @@
vpnUidCallback.assertNoCallback();
vpnUidDefaultCallback.assertNoCallback();
vpnDefaultCallbackAsUid.assertNoCallback();
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_WIFI, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.DISCONNECTED);
assertNetworkInfo(TYPE_WIFI, DetailedState.CONNECTED);
@@ -9606,20 +9562,20 @@
vpnUidCallback.assertNoCallback();
vpnUidDefaultCallback.assertNoCallback();
vpnDefaultCallbackAsUid.assertNoCallback();
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_WIFI, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.DISCONNECTED);
assertNetworkInfo(TYPE_WIFI, DetailedState.CONNECTED);
// Enable lockdown and connect a VPN. The VPN is not blocked.
mMockVpn.setAlwaysOnPackage(ALWAYS_ON_PACKAGE, true /* lockdown */, allowList);
- defaultCallback.expectBlockedStatusCallback(true, mWiFiNetworkAgent);
- assertBlockedCallbackInAnyOrder(callback, true, mWiFiNetworkAgent, mCellNetworkAgent);
+ defaultCallback.expectBlockedStatusCallback(true, mWiFiAgent);
+ assertBlockedCallbackInAnyOrder(callback, true, mWiFiAgent, mCellAgent);
vpnUidCallback.assertNoCallback();
vpnUidDefaultCallback.assertNoCallback();
vpnDefaultCallbackAsUid.assertNoCallback();
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
assertNull(mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_WIFI, DetailedState.BLOCKED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.BLOCKED);
@@ -9632,7 +9588,7 @@
vpnUidDefaultCallback.assertNoCallback(); // VPN does not apply to VPN_UID
vpnDefaultCallbackAsUid.assertNoCallback();
assertEquals(mMockVpn.getNetwork(), mCm.getActiveNetwork());
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetworkForUid(VPN_UID));
assertActiveNetworkInfo(TYPE_WIFI, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.DISCONNECTED);
assertNetworkInfo(TYPE_VPN, DetailedState.CONNECTED);
@@ -9640,7 +9596,7 @@
mMockVpn.disconnect();
defaultCallback.expect(LOST, mMockVpn);
- defaultCallback.expectAvailableCallbacksUnvalidatedAndBlocked(mWiFiNetworkAgent);
+ defaultCallback.expectAvailableCallbacksUnvalidatedAndBlocked(mWiFiAgent);
vpnUidCallback.assertNoCallback();
vpnUidDefaultCallback.assertNoCallback();
vpnDefaultCallbackAsUid.assertNoCallback();
@@ -9659,8 +9615,8 @@
mServiceContext.setPermission(NETWORK_SETTINGS, PERMISSION_GRANTED);
// Connect Wi-Fi.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true /* validated */);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true /* validated */);
// Connect a VPN that excludes its UID from its UID ranges.
final LinkProperties lp = new LinkProperties();
@@ -9669,7 +9625,7 @@
final Set<UidRange> ranges = new ArraySet<>();
ranges.add(new UidRange(0, myUid - 1));
ranges.add(new UidRange(myUid + 1, UserHandle.PER_USER_RANGE - 1));
- mMockVpn.setUnderlyingNetworks(new Network[]{mWiFiNetworkAgent.getNetwork()});
+ mMockVpn.setUnderlyingNetworks(new Network[] { mWiFiAgent.getNetwork() });
mMockVpn.establish(lp, myUid, ranges);
// Wait for validation before registering callbacks.
@@ -9691,8 +9647,8 @@
perUidCb.expectAvailableCallbacksValidated(mMockVpn);
// getActiveNetwork is not affected by this bug.
assertEquals(mMockVpn.getNetwork(), mCm.getActiveNetworkForUid(myUid + 1));
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(myUid));
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetworkForUid(myUid));
doAsUid(otherUid, () -> mCm.unregisterNetworkCallback(otherUidCb));
mCm.unregisterNetworkCallback(defaultCb);
@@ -9775,11 +9731,11 @@
cellLp.setInterfaceName("rmnet0");
cellLp.addLinkAddress(new LinkAddress("2001:db8::1/64"));
cellLp.addRoute(new RouteInfo(new IpPrefix("::/0"), null, "rmnet0"));
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
- mCellNetworkAgent.connect(false /* validated */);
- callback.expectAvailableCallbacksUnvalidatedAndBlocked(mCellNetworkAgent);
- defaultCallback.expectAvailableCallbacksUnvalidatedAndBlocked(mCellNetworkAgent);
- systemDefaultCallback.expectAvailableCallbacksUnvalidatedAndBlocked(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
+ mCellAgent.connect(false /* validated */);
+ callback.expectAvailableCallbacksUnvalidatedAndBlocked(mCellAgent);
+ defaultCallback.expectAvailableCallbacksUnvalidatedAndBlocked(mCellAgent);
+ systemDefaultCallback.expectAvailableCallbacksUnvalidatedAndBlocked(mCellAgent);
waitForIdle();
assertNull(mMockVpn.getAgent());
@@ -9788,36 +9744,36 @@
// TODO: consider fixing this.
cellLp.addLinkAddress(new LinkAddress("192.0.2.2/25"));
cellLp.addRoute(new RouteInfo(new IpPrefix("0.0.0.0/0"), null, "rmnet0"));
- mCellNetworkAgent.sendLinkProperties(cellLp);
- callback.expect(LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
- defaultCallback.expect(LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
- systemDefaultCallback.expect(LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
+ mCellAgent.sendLinkProperties(cellLp);
+ callback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
+ defaultCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
+ systemDefaultCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
waitForIdle();
assertNull(mMockVpn.getAgent());
// Disconnect, then try again with a network that supports IPv4 at connection time.
// Expect lockdown VPN to come up.
ExpectedBroadcast b1 = expectConnectivityAction(TYPE_MOBILE, DetailedState.DISCONNECTED);
- mCellNetworkAgent.disconnect();
- callback.expect(LOST, mCellNetworkAgent);
- defaultCallback.expect(LOST, mCellNetworkAgent);
- systemDefaultCallback.expect(LOST, mCellNetworkAgent);
+ mCellAgent.disconnect();
+ callback.expect(LOST, mCellAgent);
+ defaultCallback.expect(LOST, mCellAgent);
+ systemDefaultCallback.expect(LOST, mCellAgent);
b1.expectBroadcast();
// When lockdown VPN is active, the NetworkInfo state in CONNECTIVITY_ACTION is overwritten
// with the state of the VPN network. So expect a CONNECTING broadcast.
b1 = expectConnectivityAction(TYPE_MOBILE, DetailedState.CONNECTING);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
- mCellNetworkAgent.connect(false /* validated */);
- callback.expectAvailableCallbacksUnvalidatedAndBlocked(mCellNetworkAgent);
- defaultCallback.expectAvailableCallbacksUnvalidatedAndBlocked(mCellNetworkAgent);
- systemDefaultCallback.expectAvailableCallbacksUnvalidatedAndBlocked(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
+ mCellAgent.connect(false /* validated */);
+ callback.expectAvailableCallbacksUnvalidatedAndBlocked(mCellAgent);
+ defaultCallback.expectAvailableCallbacksUnvalidatedAndBlocked(mCellAgent);
+ systemDefaultCallback.expectAvailableCallbacksUnvalidatedAndBlocked(mCellAgent);
b1.expectBroadcast();
assertActiveNetworkInfo(TYPE_MOBILE, DetailedState.BLOCKED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.BLOCKED);
assertNetworkInfo(TYPE_WIFI, DetailedState.BLOCKED);
assertNetworkInfo(TYPE_VPN, DetailedState.BLOCKED);
- assertExtraInfoFromCmBlocked(mCellNetworkAgent);
+ assertExtraInfoFromCmBlocked(mCellAgent);
// TODO: it would be nice if we could simply rely on the production code here, and have
// LockdownVpnTracker start the VPN, have the VPN code register its NetworkAgent with
@@ -9835,7 +9791,7 @@
mMockVpn.expectStartLegacyVpnRunner();
b1 = expectConnectivityAction(TYPE_VPN, DetailedState.CONNECTED);
ExpectedBroadcast b2 = expectConnectivityAction(TYPE_MOBILE, DetailedState.CONNECTED);
- establishLegacyLockdownVpn(mCellNetworkAgent.getNetwork());
+ establishLegacyLockdownVpn(mCellAgent.getNetwork());
callback.expectAvailableThenValidatedCallbacks(mMockVpn);
defaultCallback.expectAvailableThenValidatedCallbacks(mMockVpn);
systemDefaultCallback.assertNoCallback();
@@ -9846,7 +9802,7 @@
assertNetworkInfo(TYPE_MOBILE, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_WIFI, DetailedState.DISCONNECTED);
assertNetworkInfo(TYPE_VPN, DetailedState.CONNECTED);
- assertExtraInfoFromCmPresent(mCellNetworkAgent);
+ assertExtraInfoFromCmPresent(mCellAgent);
assertTrue(vpnNc.hasTransport(TRANSPORT_VPN));
assertTrue(vpnNc.hasTransport(TRANSPORT_CELLULAR));
assertFalse(vpnNc.hasTransport(TRANSPORT_WIFI));
@@ -9861,13 +9817,13 @@
final NetworkCapabilities wifiNc = new NetworkCapabilities();
wifiNc.addTransportType(TRANSPORT_WIFI);
wifiNc.addCapability(NET_CAPABILITY_NOT_METERED);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp, wifiNc);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp, wifiNc);
b1 = expectConnectivityAction(TYPE_MOBILE, DetailedState.DISCONNECTED);
// Wifi is CONNECTING because the VPN isn't up yet.
b2 = expectConnectivityAction(TYPE_WIFI, DetailedState.CONNECTING);
ExpectedBroadcast b3 = expectConnectivityAction(TYPE_VPN, DetailedState.DISCONNECTED);
- mWiFiNetworkAgent.connect(false /* validated */);
+ mWiFiAgent.connect(false /* validated */);
b1.expectBroadcast();
b2.expectBroadcast();
b3.expectBroadcast();
@@ -9878,23 +9834,23 @@
// connected, so the network is not considered blocked by the lockdown UID ranges? But the
// fact that a VPN is connected should only result in the VPN itself being unblocked, not
// any other network. Bug in isUidBlockedByVpn?
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
callback.expect(LOST, mMockVpn);
defaultCallback.expect(LOST, mMockVpn);
- defaultCallback.expectAvailableCallbacksUnvalidatedAndBlocked(mWiFiNetworkAgent);
- systemDefaultCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ defaultCallback.expectAvailableCallbacksUnvalidatedAndBlocked(mWiFiAgent);
+ systemDefaultCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
// While the VPN is reconnecting on the new network, everything is blocked.
assertActiveNetworkInfo(TYPE_WIFI, DetailedState.BLOCKED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.BLOCKED);
assertNetworkInfo(TYPE_WIFI, DetailedState.BLOCKED);
assertNetworkInfo(TYPE_VPN, DetailedState.BLOCKED);
- assertExtraInfoFromCmBlocked(mWiFiNetworkAgent);
+ assertExtraInfoFromCmBlocked(mWiFiAgent);
// The VPN comes up again on wifi.
b1 = expectConnectivityAction(TYPE_VPN, DetailedState.CONNECTED);
b2 = expectConnectivityAction(TYPE_WIFI, DetailedState.CONNECTED);
- establishLegacyLockdownVpn(mWiFiNetworkAgent.getNetwork());
+ establishLegacyLockdownVpn(mWiFiAgent.getNetwork());
callback.expectAvailableThenValidatedCallbacks(mMockVpn);
defaultCallback.expectAvailableThenValidatedCallbacks(mMockVpn);
systemDefaultCallback.assertNoCallback();
@@ -9904,7 +9860,7 @@
assertNetworkInfo(TYPE_MOBILE, DetailedState.DISCONNECTED);
assertNetworkInfo(TYPE_WIFI, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_VPN, DetailedState.CONNECTED);
- assertExtraInfoFromCmPresent(mWiFiNetworkAgent);
+ assertExtraInfoFromCmPresent(mWiFiAgent);
vpnNc = mCm.getNetworkCapabilities(mMockVpn.getNetwork());
assertTrue(vpnNc.hasTransport(TRANSPORT_VPN));
assertTrue(vpnNc.hasTransport(TRANSPORT_WIFI));
@@ -9912,8 +9868,8 @@
assertTrue(vpnNc.hasCapability(NET_CAPABILITY_NOT_METERED));
// Disconnect cell. Nothing much happens since it's not the default network.
- mCellNetworkAgent.disconnect();
- callback.expect(LOST, mCellNetworkAgent);
+ mCellAgent.disconnect();
+ callback.expect(LOST, mCellAgent);
defaultCallback.assertNoCallback();
systemDefaultCallback.assertNoCallback();
@@ -9921,13 +9877,13 @@
assertNetworkInfo(TYPE_MOBILE, DetailedState.DISCONNECTED);
assertNetworkInfo(TYPE_WIFI, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_VPN, DetailedState.CONNECTED);
- assertExtraInfoFromCmPresent(mWiFiNetworkAgent);
+ assertExtraInfoFromCmPresent(mWiFiAgent);
b1 = expectConnectivityAction(TYPE_WIFI, DetailedState.DISCONNECTED);
b2 = expectConnectivityAction(TYPE_VPN, DetailedState.DISCONNECTED);
- mWiFiNetworkAgent.disconnect();
- callback.expect(LOST, mWiFiNetworkAgent);
- systemDefaultCallback.expect(LOST, mWiFiNetworkAgent);
+ mWiFiAgent.disconnect();
+ callback.expect(LOST, mWiFiAgent);
+ systemDefaultCallback.expect(LOST, mWiFiAgent);
b1.expectBroadcast();
callback.expectCapabilitiesThat(mMockVpn, nc -> !nc.hasTransport(TRANSPORT_WIFI));
mMockVpn.expectStopVpnRunnerPrivileged();
@@ -10078,32 +10034,32 @@
callbackWithoutCap);
// Setup networks with testing capability and verify the default network changes.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.addCapability(testCap);
- mCellNetworkAgent.connect(true);
- callbackWithCap.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- callbackWithoutCap.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- verify(mMockNetd).networkSetDefault(eq(mCellNetworkAgent.getNetwork().netId));
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.addCapability(testCap);
+ mCellAgent.connect(true);
+ callbackWithCap.expectAvailableThenValidatedCallbacks(mCellAgent);
+ callbackWithoutCap.expectAvailableThenValidatedCallbacks(mCellAgent);
+ verify(mMockNetd).networkSetDefault(eq(mCellAgent.getNetwork().netId));
reset(mMockNetd);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.addCapability(testCap);
- mWiFiNetworkAgent.connect(true);
- callbackWithCap.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
- callbackWithoutCap.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
- verify(mMockNetd).networkSetDefault(eq(mWiFiNetworkAgent.getNetwork().netId));
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.addCapability(testCap);
+ mWiFiAgent.connect(true);
+ callbackWithCap.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
+ callbackWithoutCap.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
+ verify(mMockNetd).networkSetDefault(eq(mWiFiAgent.getNetwork().netId));
reset(mMockNetd);
// Remove the testing capability on wifi, verify the callback and default network
// changes back to cellular.
- mWiFiNetworkAgent.removeCapability(testCap);
- callbackWithCap.expectAvailableCallbacksValidated(mCellNetworkAgent);
- callbackWithoutCap.expectCapabilitiesWithout(testCap, mWiFiNetworkAgent);
- verify(mMockNetd).networkSetDefault(eq(mCellNetworkAgent.getNetwork().netId));
+ mWiFiAgent.removeCapability(testCap);
+ callbackWithCap.expectAvailableCallbacksValidated(mCellAgent);
+ callbackWithoutCap.expectCapabilitiesWithout(testCap, mWiFiAgent);
+ verify(mMockNetd).networkSetDefault(eq(mCellAgent.getNetwork().netId));
reset(mMockNetd);
- mCellNetworkAgent.removeCapability(testCap);
- callbackWithCap.expect(LOST, mCellNetworkAgent);
+ mCellAgent.removeCapability(testCap);
+ callbackWithCap.expect(LOST, mCellAgent);
callbackWithoutCap.assertNoCallback();
verify(mMockNetd).networkClearDefault();
@@ -10116,8 +10072,8 @@
public final void testBatteryStatsNetworkType() throws Exception {
final LinkProperties cellLp = new LinkProperties();
cellLp.setInterfaceName("cell0");
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
+ mCellAgent.connect(true);
waitForIdle();
final ArrayTrackRecord<ReportedInterfaces>.ReadHead readHead =
mDeps.mReportedInterfaceHistory.newReadHead();
@@ -10127,24 +10083,24 @@
final LinkProperties wifiLp = new LinkProperties();
wifiLp.setInterfaceName("wifi0");
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
+ mWiFiAgent.connect(true);
waitForIdle();
assertNotNull(readHead.poll(TIMEOUT_MS, ri -> ri.contentEquals(mServiceContext,
wifiLp.getInterfaceName(),
new int[] { TRANSPORT_WIFI })));
- mCellNetworkAgent.disconnect();
- mWiFiNetworkAgent.disconnect();
+ mCellAgent.disconnect();
+ mWiFiAgent.disconnect();
cellLp.setInterfaceName("wifi0");
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
+ mCellAgent.connect(true);
waitForIdle();
assertNotNull(readHead.poll(TIMEOUT_MS, ri -> ri.contentEquals(mServiceContext,
cellLp.getInterfaceName(),
new int[] { TRANSPORT_CELLULAR })));
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
}
/**
@@ -10265,12 +10221,12 @@
cellLp.addLinkAddress(myIpv6);
cellLp.addRoute(ipv6Default);
cellLp.addRoute(ipv6Subnet);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
reset(mClatCoordinator);
// Connect with ipv6 link properties. Expect prefix discovery to be started.
- mCellNetworkAgent.connect(true);
- int cellNetId = mCellNetworkAgent.getNetwork().netId;
+ mCellAgent.connect(true);
+ int cellNetId = mCellAgent.getNetwork().netId;
waitForIdle();
verify(mMockNetd, times(1)).networkCreate(nativeNetworkConfigPhysical(cellNetId,
@@ -10284,7 +10240,7 @@
cellLp.getInterfaceName(),
new int[] { TRANSPORT_CELLULAR })));
- networkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ networkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
verify(mMockDnsResolver, times(1)).startPrefix64Discovery(cellNetId);
// Switching default network updates TCP buffer sizes.
@@ -10292,8 +10248,8 @@
// Add an IPv4 address. Expect prefix discovery to be stopped. Netd doesn't tell us that
// the NAT64 prefix was removed because one was never discovered.
cellLp.addLinkAddress(myIpv4);
- mCellNetworkAgent.sendLinkProperties(cellLp);
- networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
+ mCellAgent.sendLinkProperties(cellLp);
+ networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
assertRoutesAdded(cellNetId, ipv4Subnet);
verify(mMockDnsResolver, times(1)).stopPrefix64Discovery(cellNetId);
verify(mMockDnsResolver, atLeastOnce()).setResolverConfiguration(any());
@@ -10315,37 +10271,37 @@
// Remove IPv4 address. Expect prefix discovery to be started again.
cellLp.removeLinkAddress(myIpv4);
- mCellNetworkAgent.sendLinkProperties(cellLp);
- networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
+ mCellAgent.sendLinkProperties(cellLp);
+ networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
verify(mMockDnsResolver, times(1)).startPrefix64Discovery(cellNetId);
assertRoutesRemoved(cellNetId, ipv4Subnet);
// When NAT64 prefix discovery succeeds, LinkProperties are updated and clatd is started.
- Nat464Xlat clat = getNat464Xlat(mCellNetworkAgent);
- assertNull(mCm.getLinkProperties(mCellNetworkAgent.getNetwork()).getNat64Prefix());
+ Nat464Xlat clat = getNat464Xlat(mCellAgent);
+ assertNull(mCm.getLinkProperties(mCellAgent.getNetwork()).getNat64Prefix());
mService.mResolverUnsolEventCallback.onNat64PrefixEvent(
makeNat64PrefixEvent(cellNetId, PREFIX_OPERATION_ADDED, kNat64PrefixString, 96));
LinkProperties lpBeforeClat = networkCallback.expect(
- LINK_PROPERTIES_CHANGED, mCellNetworkAgent).getLp();
+ LINK_PROPERTIES_CHANGED, mCellAgent).getLp();
assertEquals(0, lpBeforeClat.getStackedLinks().size());
assertEquals(kNat64Prefix, lpBeforeClat.getNat64Prefix());
verifyClatdStart(null /* inOrder */, MOBILE_IFNAME, cellNetId, kNat64Prefix.toString());
// Clat iface comes up. Expect stacked link to be added.
clat.interfaceLinkStateChanged(CLAT_MOBILE_IFNAME, true);
- networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
- List<LinkProperties> stackedLps = mCm.getLinkProperties(mCellNetworkAgent.getNetwork())
+ networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
+ List<LinkProperties> stackedLps = mCm.getLinkProperties(mCellAgent.getNetwork())
.getStackedLinks();
assertEquals(makeClatLinkProperties(myIpv4), stackedLps.get(0));
assertRoutesAdded(cellNetId, stackedDefault);
verify(mMockNetd, times(1)).networkAddInterface(cellNetId, CLAT_MOBILE_IFNAME);
// Change trivial linkproperties and see if stacked link is preserved.
cellLp.addDnsServer(InetAddress.getByName("8.8.8.8"));
- mCellNetworkAgent.sendLinkProperties(cellLp);
- networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
+ mCellAgent.sendLinkProperties(cellLp);
+ networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
List<LinkProperties> stackedLpsAfterChange =
- mCm.getLinkProperties(mCellNetworkAgent.getNetwork()).getStackedLinks();
+ mCm.getLinkProperties(mCellAgent.getNetwork()).getStackedLinks();
assertNotEquals(stackedLpsAfterChange, Collections.EMPTY_LIST);
assertEquals(makeClatLinkProperties(myIpv4), stackedLpsAfterChange.get(0));
@@ -10368,7 +10324,7 @@
// Expect clatd to be stopped and started with the new prefix.
mService.mResolverUnsolEventCallback.onNat64PrefixEvent(makeNat64PrefixEvent(
cellNetId, PREFIX_OPERATION_ADDED, kOtherNat64PrefixString, 96));
- networkCallback.expectLinkPropertiesThat(mCellNetworkAgent,
+ networkCallback.expectLinkPropertiesThat(mCellAgent,
(lp) -> lp.getStackedLinks().size() == 0);
verifyClatdStop(null /* inOrder */, MOBILE_IFNAME);
assertRoutesRemoved(cellNetId, stackedDefault);
@@ -10376,10 +10332,10 @@
verifyClatdStart(null /* inOrder */, MOBILE_IFNAME, cellNetId,
kOtherNat64Prefix.toString());
- networkCallback.expectLinkPropertiesThat(mCellNetworkAgent,
+ networkCallback.expectLinkPropertiesThat(mCellAgent,
(lp) -> lp.getNat64Prefix().equals(kOtherNat64Prefix));
clat.interfaceLinkStateChanged(CLAT_MOBILE_IFNAME, true);
- networkCallback.expectLinkPropertiesThat(mCellNetworkAgent,
+ networkCallback.expectLinkPropertiesThat(mCellAgent,
(lp) -> lp.getStackedLinks().size() == 1);
assertRoutesAdded(cellNetId, stackedDefault);
verify(mMockNetd, times(1)).networkAddInterface(cellNetId, CLAT_MOBILE_IFNAME);
@@ -10390,15 +10346,15 @@
// linkproperties are cleaned up.
cellLp.addLinkAddress(myIpv4);
cellLp.addRoute(ipv4Subnet);
- mCellNetworkAgent.sendLinkProperties(cellLp);
- networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
+ mCellAgent.sendLinkProperties(cellLp);
+ networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
assertRoutesAdded(cellNetId, ipv4Subnet);
verifyClatdStop(null /* inOrder */, MOBILE_IFNAME);
verify(mMockDnsResolver, times(1)).stopPrefix64Discovery(cellNetId);
// As soon as stop is called, the linkproperties lose the stacked interface.
- networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
- LinkProperties actualLpAfterIpv4 = mCm.getLinkProperties(mCellNetworkAgent.getNetwork());
+ networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
+ LinkProperties actualLpAfterIpv4 = mCm.getLinkProperties(mCellAgent.getNetwork());
LinkProperties expected = new LinkProperties(cellLp);
expected.setNat64Prefix(kOtherNat64Prefix);
assertEquals(expected, actualLpAfterIpv4);
@@ -10421,45 +10377,44 @@
// Stopping prefix discovery causes netd to tell us that the NAT64 prefix is gone.
mService.mResolverUnsolEventCallback.onNat64PrefixEvent(makeNat64PrefixEvent(
cellNetId, PREFIX_OPERATION_REMOVED, kOtherNat64PrefixString, 96));
- networkCallback.expectLinkPropertiesThat(mCellNetworkAgent,
- (lp) -> lp.getNat64Prefix() == null);
+ networkCallback.expectLinkPropertiesThat(mCellAgent, lp -> lp.getNat64Prefix() == null);
// Remove IPv4 address and expect prefix discovery and clatd to be started again.
cellLp.removeLinkAddress(myIpv4);
cellLp.removeRoute(new RouteInfo(myIpv4, null, MOBILE_IFNAME));
cellLp.removeDnsServer(InetAddress.getByName("8.8.8.8"));
- mCellNetworkAgent.sendLinkProperties(cellLp);
- networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
+ mCellAgent.sendLinkProperties(cellLp);
+ networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
assertRoutesRemoved(cellNetId, ipv4Subnet); // Directly-connected routes auto-added.
verify(mMockDnsResolver, times(1)).startPrefix64Discovery(cellNetId);
mService.mResolverUnsolEventCallback.onNat64PrefixEvent(makeNat64PrefixEvent(
cellNetId, PREFIX_OPERATION_ADDED, kNat64PrefixString, 96));
- networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
+ networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
verifyClatdStart(null /* inOrder */, MOBILE_IFNAME, cellNetId, kNat64Prefix.toString());
// Clat iface comes up. Expect stacked link to be added.
clat.interfaceLinkStateChanged(CLAT_MOBILE_IFNAME, true);
- networkCallback.expectLinkPropertiesThat(mCellNetworkAgent,
- (lp) -> lp.getStackedLinks().size() == 1 && lp.getNat64Prefix() != null);
+ networkCallback.expectLinkPropertiesThat(mCellAgent,
+ lp -> lp.getStackedLinks().size() == 1 && lp.getNat64Prefix() != null);
assertRoutesAdded(cellNetId, stackedDefault);
verify(mMockNetd, times(1)).networkAddInterface(cellNetId, CLAT_MOBILE_IFNAME);
// NAT64 prefix is removed. Expect that clat is stopped.
mService.mResolverUnsolEventCallback.onNat64PrefixEvent(makeNat64PrefixEvent(
cellNetId, PREFIX_OPERATION_REMOVED, kNat64PrefixString, 96));
- networkCallback.expectLinkPropertiesThat(mCellNetworkAgent,
- (lp) -> lp.getStackedLinks().size() == 0 && lp.getNat64Prefix() == null);
+ networkCallback.expectLinkPropertiesThat(mCellAgent,
+ lp -> lp.getStackedLinks().size() == 0 && lp.getNat64Prefix() == null);
assertRoutesRemoved(cellNetId, ipv4Subnet, stackedDefault);
// Stop has no effect because clat is already stopped.
verifyClatdStop(null /* inOrder */, MOBILE_IFNAME);
- networkCallback.expectLinkPropertiesThat(mCellNetworkAgent,
- (lp) -> lp.getStackedLinks().size() == 0);
+ networkCallback.expectLinkPropertiesThat(mCellAgent,
+ lp -> lp.getStackedLinks().size() == 0);
verify(mMockNetd, times(1)).networkRemoveInterface(cellNetId, CLAT_MOBILE_IFNAME);
verify(mMockNetd, times(1)).interfaceGetCfg(CLAT_MOBILE_IFNAME);
// Clean up.
- mCellNetworkAgent.disconnect();
- networkCallback.expect(LOST, mCellNetworkAgent);
+ mCellAgent.disconnect();
+ networkCallback.expect(LOST, mCellAgent);
networkCallback.assertNoCallback();
verify(mMockNetd, times(1)).idletimerRemoveInterface(eq(MOBILE_IFNAME), anyInt(),
eq(Integer.toString(TRANSPORT_CELLULAR)));
@@ -10476,20 +10431,20 @@
doReturn(getClatInterfaceConfigParcel(myIpv4)).when(mMockNetd)
.interfaceGetCfg(CLAT_MOBILE_IFNAME);
cellLp.setNat64Prefix(kNat64Prefix);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
- mCellNetworkAgent.connect(false /* validated */);
- networkCallback.expectAvailableCallbacksUnvalidated(mCellNetworkAgent);
- cellNetId = mCellNetworkAgent.getNetwork().netId;
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
+ mCellAgent.connect(false /* validated */);
+ networkCallback.expectAvailableCallbacksUnvalidated(mCellAgent);
+ cellNetId = mCellAgent.getNetwork().netId;
verify(mMockNetd, times(1)).networkCreate(nativeNetworkConfigPhysical(cellNetId,
INetd.PERMISSION_NONE));
assertRoutesAdded(cellNetId, ipv6Subnet, ipv6Default);
// Clatd is started and clat iface comes up. Expect stacked link to be added.
verifyClatdStart(null /* inOrder */, MOBILE_IFNAME, cellNetId, kNat64Prefix.toString());
- clat = getNat464Xlat(mCellNetworkAgent);
+ clat = getNat464Xlat(mCellAgent);
clat.interfaceLinkStateChanged(CLAT_MOBILE_IFNAME, true /* up */);
- networkCallback.expectLinkPropertiesThat(mCellNetworkAgent,
- (lp) -> lp.getStackedLinks().size() == 1
+ networkCallback.expectLinkPropertiesThat(mCellAgent,
+ lp -> lp.getStackedLinks().size() == 1
&& lp.getNat64Prefix().equals(kNat64Prefix));
verify(mMockNetd).networkAddInterface(cellNetId, CLAT_MOBILE_IFNAME);
// assertRoutesAdded sees all calls since last mMockNetd reset, so expect IPv6 routes again.
@@ -10498,8 +10453,8 @@
reset(mClatCoordinator);
// Disconnect the network. clat is stopped and the network is destroyed.
- mCellNetworkAgent.disconnect();
- networkCallback.expect(LOST, mCellNetworkAgent);
+ mCellAgent.disconnect();
+ networkCallback.expect(LOST, mCellAgent);
networkCallback.assertNoCallback();
verifyClatdStop(null /* inOrder */, MOBILE_IFNAME);
verify(mMockNetd).idletimerRemoveInterface(eq(MOBILE_IFNAME), anyInt(),
@@ -10544,11 +10499,11 @@
// prefix discovery is never started.
LinkProperties lp = new LinkProperties(baseLp);
lp.setNat64Prefix(pref64FromRa);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, lp);
- mWiFiNetworkAgent.connect(false);
- final Network network = mWiFiNetworkAgent.getNetwork();
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, lp);
+ mWiFiAgent.connect(false);
+ final Network network = mWiFiAgent.getNetwork();
int netId = network.getNetId();
- callback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
verifyClatdStart(inOrder, iface, netId, pref64FromRa.toString());
inOrder.verify(mMockDnsResolver).setPrefix64(netId, pref64FromRa.toString());
inOrder.verify(mMockDnsResolver, never()).startPrefix64Discovery(netId);
@@ -10557,8 +10512,8 @@
// If the RA prefix is withdrawn, clatd is stopped and prefix discovery is started.
lp.setNat64Prefix(null);
- mWiFiNetworkAgent.sendLinkProperties(lp);
- expectNat64PrefixChange(callback, mWiFiNetworkAgent, null);
+ mWiFiAgent.sendLinkProperties(lp);
+ expectNat64PrefixChange(callback, mWiFiAgent, null);
verifyClatdStop(inOrder, iface);
inOrder.verify(mMockDnsResolver).setPrefix64(netId, "");
inOrder.verify(mMockDnsResolver).startPrefix64Discovery(netId);
@@ -10566,8 +10521,8 @@
// If the RA prefix appears while DNS discovery is in progress, discovery is stopped and
// clatd is started with the prefix from the RA.
lp.setNat64Prefix(pref64FromRa);
- mWiFiNetworkAgent.sendLinkProperties(lp);
- expectNat64PrefixChange(callback, mWiFiNetworkAgent, pref64FromRa);
+ mWiFiAgent.sendLinkProperties(lp);
+ expectNat64PrefixChange(callback, mWiFiAgent, pref64FromRa);
verifyClatdStart(inOrder, iface, netId, pref64FromRa.toString());
inOrder.verify(mMockDnsResolver).stopPrefix64Discovery(netId);
inOrder.verify(mMockDnsResolver).setPrefix64(netId, pref64FromRa.toString());
@@ -10575,21 +10530,21 @@
// Withdraw the RA prefix so we can test the case where an RA prefix appears after DNS
// discovery has succeeded.
lp.setNat64Prefix(null);
- mWiFiNetworkAgent.sendLinkProperties(lp);
- expectNat64PrefixChange(callback, mWiFiNetworkAgent, null);
+ mWiFiAgent.sendLinkProperties(lp);
+ expectNat64PrefixChange(callback, mWiFiAgent, null);
verifyClatdStop(inOrder, iface);
inOrder.verify(mMockDnsResolver).setPrefix64(netId, "");
inOrder.verify(mMockDnsResolver).startPrefix64Discovery(netId);
mService.mResolverUnsolEventCallback.onNat64PrefixEvent(
makeNat64PrefixEvent(netId, PREFIX_OPERATION_ADDED, pref64FromDnsStr, 96));
- expectNat64PrefixChange(callback, mWiFiNetworkAgent, pref64FromDns);
+ expectNat64PrefixChange(callback, mWiFiAgent, pref64FromDns);
verifyClatdStart(inOrder, iface, netId, pref64FromDns.toString());
// If an RA advertises the same prefix that was discovered by DNS, nothing happens: prefix
// discovery is not stopped, and there are no callbacks.
lp.setNat64Prefix(pref64FromDns);
- mWiFiNetworkAgent.sendLinkProperties(lp);
+ mWiFiAgent.sendLinkProperties(lp);
callback.assertNoCallback();
verifyNeverClatdStop(inOrder, iface);
verifyNeverClatdStart(inOrder, iface);
@@ -10599,7 +10554,7 @@
// If the RA is later withdrawn, nothing happens again.
lp.setNat64Prefix(null);
- mWiFiNetworkAgent.sendLinkProperties(lp);
+ mWiFiAgent.sendLinkProperties(lp);
callback.assertNoCallback();
verifyNeverClatdStop(inOrder, iface);
verifyNeverClatdStart(inOrder, iface);
@@ -10609,8 +10564,8 @@
// If the RA prefix changes, clatd is restarted and prefix discovery is stopped.
lp.setNat64Prefix(pref64FromRa);
- mWiFiNetworkAgent.sendLinkProperties(lp);
- expectNat64PrefixChange(callback, mWiFiNetworkAgent, pref64FromRa);
+ mWiFiAgent.sendLinkProperties(lp);
+ expectNat64PrefixChange(callback, mWiFiAgent, pref64FromRa);
verifyClatdStop(inOrder, iface);
inOrder.verify(mMockDnsResolver).stopPrefix64Discovery(netId);
@@ -10624,8 +10579,8 @@
// If the RA prefix changes, clatd is restarted and prefix discovery is not started.
lp.setNat64Prefix(newPref64FromRa);
- mWiFiNetworkAgent.sendLinkProperties(lp);
- expectNat64PrefixChange(callback, mWiFiNetworkAgent, newPref64FromRa);
+ mWiFiAgent.sendLinkProperties(lp);
+ expectNat64PrefixChange(callback, mWiFiAgent, newPref64FromRa);
verifyClatdStop(inOrder, iface);
inOrder.verify(mMockDnsResolver).setPrefix64(netId, "");
verifyClatdStart(inOrder, iface, netId, newPref64FromRa.toString());
@@ -10635,7 +10590,7 @@
// If the RA prefix changes to the same value, nothing happens.
lp.setNat64Prefix(newPref64FromRa);
- mWiFiNetworkAgent.sendLinkProperties(lp);
+ mWiFiAgent.sendLinkProperties(lp);
callback.assertNoCallback();
assertEquals(newPref64FromRa, mCm.getLinkProperties(network).getNat64Prefix());
verifyNeverClatdStop(inOrder, iface);
@@ -10649,19 +10604,19 @@
// If the same prefix is learned first by DNS and then by RA, and clat is later stopped,
// (e.g., because the network disconnects) setPrefix64(netid, "") is never called.
lp.setNat64Prefix(null);
- mWiFiNetworkAgent.sendLinkProperties(lp);
- expectNat64PrefixChange(callback, mWiFiNetworkAgent, null);
+ mWiFiAgent.sendLinkProperties(lp);
+ expectNat64PrefixChange(callback, mWiFiAgent, null);
verifyClatdStop(inOrder, iface);
inOrder.verify(mMockDnsResolver).setPrefix64(netId, "");
inOrder.verify(mMockDnsResolver).startPrefix64Discovery(netId);
mService.mResolverUnsolEventCallback.onNat64PrefixEvent(
makeNat64PrefixEvent(netId, PREFIX_OPERATION_ADDED, pref64FromDnsStr, 96));
- expectNat64PrefixChange(callback, mWiFiNetworkAgent, pref64FromDns);
+ expectNat64PrefixChange(callback, mWiFiAgent, pref64FromDns);
verifyClatdStart(inOrder, iface, netId, pref64FromDns.toString());
inOrder.verify(mMockDnsResolver, never()).setPrefix64(eq(netId), any());
lp.setNat64Prefix(pref64FromDns);
- mWiFiNetworkAgent.sendLinkProperties(lp);
+ mWiFiAgent.sendLinkProperties(lp);
callback.assertNoCallback();
verifyNeverClatdStop(inOrder, iface);
verifyNeverClatdStart(inOrder, iface);
@@ -10673,8 +10628,8 @@
// before CONNECTIVITY_ACTION is sent. Wait for CONNECTIVITY_ACTION before verifying that
// clat has been stopped, or the test will be flaky.
ExpectedBroadcast b = expectConnectivityAction(TYPE_WIFI, DetailedState.DISCONNECTED);
- mWiFiNetworkAgent.disconnect();
- callback.expect(LOST, mWiFiNetworkAgent);
+ mWiFiAgent.disconnect();
+ callback.expect(LOST, mWiFiAgent);
b.expectBroadcast();
verifyClatdStop(inOrder, iface);
@@ -10701,17 +10656,17 @@
cellLp.setInterfaceName(MOBILE_IFNAME);
cellLp.addLinkAddress(new LinkAddress("2001:db8:1::1/64"));
cellLp.addRoute(new RouteInfo(new IpPrefix("::/0"), null, MOBILE_IFNAME));
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.sendLinkProperties(cellLp);
- mCellNetworkAgent.connect(true);
- callback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- defaultCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- final int cellNetId = mCellNetworkAgent.getNetwork().netId;
+ mCellAgent.sendLinkProperties(cellLp);
+ mCellAgent.connect(true);
+ callback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ defaultCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ final int cellNetId = mCellAgent.getNetwork().netId;
waitForIdle();
verify(mMockDnsResolver, never()).startPrefix64Discovery(cellNetId);
- Nat464Xlat clat = getNat464Xlat(mCellNetworkAgent);
+ Nat464Xlat clat = getNat464Xlat(mCellAgent);
assertTrue("Nat464Xlat was not IDLE", !clat.isStarted());
// This cannot happen because prefix discovery cannot succeed if it is never started.
@@ -10731,25 +10686,25 @@
.build();
mCm.registerNetworkCallback(networkRequest, networkCallback);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
final LinkProperties cellLp = new LinkProperties();
cellLp.setInterfaceName(MOBILE_IFNAME);
- mCellNetworkAgent.sendLinkProperties(cellLp);
- mCellNetworkAgent.connect(true);
- networkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent.sendLinkProperties(cellLp);
+ mCellAgent.connect(true);
+ networkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
verify(mMockNetd, times(1)).idletimerAddInterface(eq(MOBILE_IFNAME), anyInt(),
eq(Integer.toString(TRANSPORT_CELLULAR)));
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
final LinkProperties wifiLp = new LinkProperties();
wifiLp.setInterfaceName(WIFI_IFNAME);
- mWiFiNetworkAgent.sendLinkProperties(wifiLp);
+ mWiFiAgent.sendLinkProperties(wifiLp);
// Network switch
- mWiFiNetworkAgent.connect(true);
- networkCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- networkCallback.expectLosing(mCellNetworkAgent);
- networkCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
+ mWiFiAgent.connect(true);
+ networkCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ networkCallback.expectLosing(mCellAgent);
+ networkCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
verify(mMockNetd, times(1)).idletimerAddInterface(eq(WIFI_IFNAME), anyInt(),
eq(Integer.toString(TRANSPORT_WIFI)));
verify(mMockNetd, times(1)).idletimerRemoveInterface(eq(MOBILE_IFNAME), anyInt(),
@@ -10757,8 +10712,8 @@
// Disconnect wifi and switch back to cell
reset(mMockNetd);
- mWiFiNetworkAgent.disconnect();
- networkCallback.expect(LOST, mWiFiNetworkAgent);
+ mWiFiAgent.disconnect();
+ networkCallback.expect(LOST, mWiFiAgent);
assertNoCallbacks(networkCallback);
verify(mMockNetd, times(1)).idletimerRemoveInterface(eq(WIFI_IFNAME), anyInt(),
eq(Integer.toString(TRANSPORT_WIFI)));
@@ -10767,13 +10722,13 @@
// reconnect wifi
reset(mMockNetd);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
wifiLp.setInterfaceName(WIFI_IFNAME);
- mWiFiNetworkAgent.sendLinkProperties(wifiLp);
- mWiFiNetworkAgent.connect(true);
- networkCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- networkCallback.expectLosing(mCellNetworkAgent);
- networkCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
+ mWiFiAgent.sendLinkProperties(wifiLp);
+ mWiFiAgent.connect(true);
+ networkCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ networkCallback.expectLosing(mCellAgent);
+ networkCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
verify(mMockNetd, times(1)).idletimerAddInterface(eq(WIFI_IFNAME), anyInt(),
eq(Integer.toString(TRANSPORT_WIFI)));
verify(mMockNetd, times(1)).idletimerRemoveInterface(eq(MOBILE_IFNAME), anyInt(),
@@ -10781,21 +10736,20 @@
// Disconnect cell
reset(mMockNetd);
- mCellNetworkAgent.disconnect();
- networkCallback.expect(LOST, mCellNetworkAgent);
+ mCellAgent.disconnect();
+ networkCallback.expect(LOST, mCellAgent);
// LOST callback is triggered earlier than removing idle timer. Broadcast should also be
// sent as network being switched. Ensure rule removal for cell will not be triggered
// unexpectedly before network being removed.
waitForIdle();
verify(mMockNetd, times(0)).idletimerRemoveInterface(eq(MOBILE_IFNAME), anyInt(),
eq(Integer.toString(TRANSPORT_CELLULAR)));
- verify(mMockNetd, times(1)).networkDestroy(eq(mCellNetworkAgent.getNetwork().netId));
- verify(mMockDnsResolver, times(1))
- .destroyNetworkCache(eq(mCellNetworkAgent.getNetwork().netId));
+ verify(mMockNetd, times(1)).networkDestroy(eq(mCellAgent.getNetwork().netId));
+ verify(mMockDnsResolver, times(1)).destroyNetworkCache(eq(mCellAgent.getNetwork().netId));
// Disconnect wifi
ExpectedBroadcast b = expectConnectivityAction(TYPE_WIFI, DetailedState.DISCONNECTED);
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
b.expectBroadcast();
verify(mMockNetd, times(1)).idletimerRemoveInterface(eq(WIFI_IFNAME), anyInt(),
eq(Integer.toString(TRANSPORT_WIFI)));
@@ -10822,21 +10776,21 @@
final TestNetworkCallback networkCallback = new TestNetworkCallback();
mCm.registerNetworkCallback(networkRequest, networkCallback);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
reset(mMockNetd);
// Switching default network updates TCP buffer sizes.
- mCellNetworkAgent.connect(false);
- networkCallback.expectAvailableCallbacksUnvalidated(mCellNetworkAgent);
+ mCellAgent.connect(false);
+ networkCallback.expectAvailableCallbacksUnvalidated(mCellAgent);
verifyTcpBufferSizeChange(ConnectivityService.DEFAULT_TCP_BUFFER_SIZES);
// Change link Properties should have updated tcp buffer size.
LinkProperties lp = new LinkProperties();
lp.setTcpBufferSizes(testTcpBufferSizes);
- mCellNetworkAgent.sendLinkProperties(lp);
- networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellNetworkAgent);
+ mCellAgent.sendLinkProperties(lp);
+ networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent);
verifyTcpBufferSizeChange(testTcpBufferSizes);
// Clean up.
- mCellNetworkAgent.disconnect();
- networkCallback.expect(LOST, mCellNetworkAgent);
+ mCellAgent.disconnect();
+ networkCallback.expect(LOST, mCellAgent);
networkCallback.assertNoCallback();
mCm.unregisterNetworkCallback(networkCallback);
}
@@ -10844,8 +10798,8 @@
@Test
public void testGetGlobalProxyForNetwork() throws Exception {
final ProxyInfo testProxyInfo = ProxyInfo.buildDirectProxy("test", 8888);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- final Network wifiNetwork = mWiFiNetworkAgent.getNetwork();
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ final Network wifiNetwork = mWiFiAgent.getNetwork();
mProxyTracker.setGlobalProxy(testProxyInfo);
assertEquals(testProxyInfo, mService.getProxyForNetwork(wifiNetwork));
}
@@ -10853,15 +10807,15 @@
@Test
public void testGetProxyForActiveNetwork() throws Exception {
final ProxyInfo testProxyInfo = ProxyInfo.buildDirectProxy("test", 8888);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
waitForIdle();
assertNull(mService.getProxyForNetwork(null));
final LinkProperties testLinkProperties = new LinkProperties();
testLinkProperties.setHttpProxy(testProxyInfo);
- mWiFiNetworkAgent.sendLinkProperties(testLinkProperties);
+ mWiFiAgent.sendLinkProperties(testLinkProperties);
waitForIdle();
assertEquals(testProxyInfo, mService.getProxyForNetwork(null));
@@ -10872,8 +10826,8 @@
final ProxyInfo testProxyInfo = ProxyInfo.buildDirectProxy("test", 8888);
// Set up a WiFi network with no proxy
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
waitForIdle();
assertNull(mService.getProxyForNetwork(null));
@@ -10886,7 +10840,7 @@
// Test that the VPN network returns a proxy, and the WiFi does not.
assertEquals(testProxyInfo, mService.getProxyForNetwork(mMockVpn.getNetwork()));
assertEquals(testProxyInfo, mService.getProxyForNetwork(null));
- assertNull(mService.getProxyForNetwork(mWiFiNetworkAgent.getNetwork()));
+ assertNull(mService.getProxyForNetwork(mWiFiAgent.getNetwork()));
// Test that the VPN network returns no proxy when it is set to null.
testLinkProperties.setHttpProxy(null);
@@ -10897,7 +10851,7 @@
// Set WiFi proxy and check that the vpn proxy is still null.
testLinkProperties.setHttpProxy(testProxyInfo);
- mWiFiNetworkAgent.sendLinkProperties(testLinkProperties);
+ mWiFiAgent.sendLinkProperties(testLinkProperties);
waitForIdle();
assertNull(mService.getProxyForNetwork(null));
@@ -10905,8 +10859,8 @@
// correct proxy setting.
mMockVpn.disconnect();
waitForIdle();
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
- assertEquals(testProxyInfo, mService.getProxyForNetwork(mWiFiNetworkAgent.getNetwork()));
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(testProxyInfo, mService.getProxyForNetwork(mWiFiAgent.getNetwork()));
assertEquals(testProxyInfo, mService.getProxyForNetwork(null));
}
@@ -11085,15 +11039,15 @@
@Test
public void testLinkPropertiesWithWakeOnLanForActiveNetwork() throws Exception {
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
LinkProperties wifiLp = new LinkProperties();
wifiLp.setInterfaceName(WIFI_WOL_IFNAME);
wifiLp.setWakeOnLanSupported(false);
// Default network switch should update ifaces.
- mWiFiNetworkAgent.connect(false);
- mWiFiNetworkAgent.sendLinkProperties(wifiLp);
+ mWiFiAgent.connect(false);
+ mWiFiAgent.sendLinkProperties(wifiLp);
waitForIdle();
// ConnectivityService should have changed the WakeOnLanSupported to true
@@ -11485,18 +11439,17 @@
.addTransportType(TRANSPORT_WIFI).build();
mCm.registerNetworkCallback(wifiRequest, wifiNetworkCallback);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, new LinkProperties(),
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, new LinkProperties(),
ncTemplate);
- mWiFiNetworkAgent.connect(false);
+ mWiFiAgent.connect(false);
- wifiNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ wifiNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
// Send network capabilities update with TransportInfo to trigger capabilities changed
// callback.
- mWiFiNetworkAgent.setNetworkCapabilities(
- ncTemplate.setTransportInfo(actualTransportInfo), true);
+ mWiFiAgent.setNetworkCapabilities(ncTemplate.setTransportInfo(actualTransportInfo), true);
- wifiNetworkCallback.expectCapabilitiesThat(mWiFiNetworkAgent,
+ wifiNetworkCallback.expectCapabilitiesThat(mWiFiAgent,
nc -> Objects.equals(expectedOwnerUid, nc.getOwnerUid())
&& Objects.equals(expectedTransportInfo, nc.getTransportInfo()));
}
@@ -11525,32 +11478,31 @@
.addTransportType(TRANSPORT_WIFI)
.setTransportInfo(new TestTransportInfo());
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, new LinkProperties(),
- ncTemplate);
- mWiFiNetworkAgent.connect(true /* validated; waits for callback */);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, new LinkProperties(), ncTemplate);
+ mWiFiAgent.connect(true /* validated; waits for callback */);
// NETWORK_SETTINGS redaction is controlled by the NETWORK_SETTINGS permission
- assertTrue(getTestTransportInfo(mWiFiNetworkAgent).settingsRedacted);
+ assertTrue(getTestTransportInfo(mWiFiAgent).settingsRedacted);
withPermission(NETWORK_SETTINGS, () -> {
- assertFalse(getTestTransportInfo(mWiFiNetworkAgent).settingsRedacted);
+ assertFalse(getTestTransportInfo(mWiFiAgent).settingsRedacted);
});
- assertTrue(getTestTransportInfo(mWiFiNetworkAgent).settingsRedacted);
+ assertTrue(getTestTransportInfo(mWiFiAgent).settingsRedacted);
// LOCAL_MAC_ADDRESS redaction is controlled by the LOCAL_MAC_ADDRESS permission
- assertTrue(getTestTransportInfo(mWiFiNetworkAgent).localMacAddressRedacted);
+ assertTrue(getTestTransportInfo(mWiFiAgent).localMacAddressRedacted);
withPermission(LOCAL_MAC_ADDRESS, () -> {
- assertFalse(getTestTransportInfo(mWiFiNetworkAgent).localMacAddressRedacted);
+ assertFalse(getTestTransportInfo(mWiFiAgent).localMacAddressRedacted);
});
- assertTrue(getTestTransportInfo(mWiFiNetworkAgent).localMacAddressRedacted);
+ assertTrue(getTestTransportInfo(mWiFiAgent).localMacAddressRedacted);
// Synchronous getNetworkCapabilities calls never return unredacted location-sensitive
// information.
- assertTrue(getTestTransportInfo(mWiFiNetworkAgent).locationRedacted);
+ assertTrue(getTestTransportInfo(mWiFiAgent).locationRedacted);
setupLocationPermissions(Build.VERSION_CODES.S, true, AppOpsManager.OPSTR_FINE_LOCATION,
Manifest.permission.ACCESS_FINE_LOCATION);
- assertTrue(getTestTransportInfo(mWiFiNetworkAgent).locationRedacted);
+ assertTrue(getTestTransportInfo(mWiFiAgent).locationRedacted);
denyAllLocationPrivilegedPermissions();
- assertTrue(getTestTransportInfo(mWiFiNetworkAgent).locationRedacted);
+ assertTrue(getTestTransportInfo(mWiFiAgent).locationRedacted);
}
private void setupConnectionOwnerUid(int vpnOwnerUid, @VpnManager.VpnType int vpnType)
@@ -11975,9 +11927,9 @@
mCm.registerDefaultNetworkCallback(callback);
final LinkProperties linkProperties = new LinkProperties();
linkProperties.setInterfaceName(INTERFACE_NAME);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, linkProperties);
- mCellNetworkAgent.connect(true);
- callback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, linkProperties);
+ mCellAgent.connect(true);
+ callback.expectAvailableThenValidatedCallbacks(mCellAgent);
callback.assertNoCallback();
final NetworkRequest request = new NetworkRequest.Builder().build();
@@ -12014,10 +11966,10 @@
final NetworkCapabilities ncTemplate = new NetworkCapabilities()
.addTransportType(TRANSPORT_CELLULAR)
.setTransportInfo(new TestTransportInfo());
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, new LinkProperties(),
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, new LinkProperties(),
ncTemplate);
- mCellNetworkAgent.connect(true);
- callback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent.connect(true);
+ callback.expectAvailableThenValidatedCallbacks(mCellAgent);
callback.assertNoCallback();
// Make sure a report is sent and that the caps are suitably redacted.
@@ -12043,7 +11995,7 @@
// Trigger notifyDataStallSuspected() on the INetworkMonitorCallbacks instance in the
// cellular network agent
- mCellNetworkAgent.notifyDataStallSuspected();
+ mCellAgent.notifyDataStallSuspected();
// Verify onDataStallSuspected fired
verify(mConnectivityDiagnosticsCallback, timeout(TIMEOUT_MS)).onDataStallSuspected(
@@ -12054,7 +12006,7 @@
public void testConnectivityDiagnosticsCallbackOnConnectivityReported() throws Exception {
setUpConnectivityDiagnosticsCallback();
- final Network n = mCellNetworkAgent.getNetwork();
+ final Network n = mCellAgent.getNetwork();
final boolean hasConnectivity = true;
mService.reportNetworkConnectivity(n, hasConnectivity);
@@ -12087,7 +12039,7 @@
// report known Connectivity from a different uid. Verify that network is not re-validated
// and this callback is not notified.
- final Network n = mCellNetworkAgent.getNetwork();
+ final Network n = mCellAgent.getNetwork();
final boolean hasConnectivity = true;
doAsUid(Process.myUid() + 1, () -> mService.reportNetworkConnectivity(n, hasConnectivity));
@@ -12139,11 +12091,11 @@
final NetworkRequest request = new NetworkRequest.Builder().build();
final TestNetworkCallback networkCallback = new TestNetworkCallback();
mCm.registerNetworkCallback(request, networkCallback);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
reset(mMockNetd);
- mCellNetworkAgent.connect(false);
- networkCallback.expectAvailableCallbacksUnvalidated(mCellNetworkAgent);
- final int netId = mCellNetworkAgent.getNetwork().netId;
+ mCellAgent.connect(false);
+ networkCallback.expectAvailableCallbacksUnvalidated(mCellAgent);
+ final int netId = mCellAgent.getNetwork().netId;
final String iface = "rmnet_data0";
final InetAddress gateway = InetAddress.getByName("fe80::5678");
@@ -12160,8 +12112,8 @@
lp.addRoute(direct);
lp.addRoute(rio1);
lp.addRoute(defaultRoute);
- mCellNetworkAgent.sendLinkProperties(lp);
- networkCallback.expectLinkPropertiesThat(mCellNetworkAgent, x -> x.getRoutes().size() == 3);
+ mCellAgent.sendLinkProperties(lp);
+ networkCallback.expectLinkPropertiesThat(mCellAgent, x -> x.getRoutes().size() == 3);
assertRoutesAdded(netId, direct, rio1, defaultRoute);
reset(mMockNetd);
@@ -12175,9 +12127,8 @@
assertFalse(lp.getRoutes().contains(defaultRoute));
assertTrue(lp.getRoutes().contains(defaultWithMtu));
- mCellNetworkAgent.sendLinkProperties(lp);
- networkCallback.expectLinkPropertiesThat(mCellNetworkAgent,
- x -> x.getRoutes().contains(rio2));
+ mCellAgent.sendLinkProperties(lp);
+ networkCallback.expectLinkPropertiesThat(mCellAgent, x -> x.getRoutes().contains(rio2));
assertRoutesRemoved(netId, rio1);
assertRoutesAdded(netId, rio2);
@@ -12289,8 +12240,8 @@
@Test
public void testVpnUidRangesUpdate() throws Exception {
// Set up a WiFi network without proxy.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
assertNull(mService.getProxyForNetwork(null));
assertNull(mCm.getDefaultProxy());
@@ -12342,11 +12293,11 @@
b5.expectBroadcast();
// Proxy is added in WiFi(default network), setDefaultProxy will be called.
- final LinkProperties wifiLp = mCm.getLinkProperties(mWiFiNetworkAgent.getNetwork());
+ final LinkProperties wifiLp = mCm.getLinkProperties(mWiFiAgent.getNetwork());
assertNotNull(wifiLp);
final ExpectedBroadcast b6 = expectProxyChangeAction(testProxyInfo);
wifiLp.setHttpProxy(testProxyInfo);
- mWiFiNetworkAgent.sendLinkProperties(wifiLp);
+ mWiFiAgent.sendLinkProperties(wifiLp);
waitForIdle();
b6.expectBroadcast();
}
@@ -12354,8 +12305,8 @@
@Test
public void testProxyBroadcastWillBeSentWhenVpnHasProxyAndConnects() throws Exception {
// Set up a WiFi network without proxy.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
assertNull(mService.getProxyForNetwork(null));
assertNull(mCm.getDefaultProxy());
@@ -12389,22 +12340,22 @@
public void testProxyBroadcastWillBeSentWhenTheProxyOfNonDefaultNetworkHasChanged()
throws Exception {
// Set up a CELLULAR network without proxy.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
assertNull(mService.getProxyForNetwork(null));
assertNull(mCm.getDefaultProxy());
// CELLULAR network should be the default network.
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
// Set up a WiFi network without proxy.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
assertNull(mService.getProxyForNetwork(null));
assertNull(mCm.getDefaultProxy());
// WiFi network should be the default network.
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
// CELLULAR network is not the default network.
- assertNotEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertNotEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
// CELLULAR network is not the system default network, but it might be a per-app default
// network. The proxy broadcast should be sent once its proxy has changed.
@@ -12413,7 +12364,7 @@
final ProxyInfo testProxyInfo = ProxyInfo.buildDirectProxy("test", 8888);
final ExpectedBroadcast b = registerPacProxyBroadcast();
cellularLp.setHttpProxy(testProxyInfo);
- mCellNetworkAgent.sendLinkProperties(cellularLp);
+ mCellAgent.sendLinkProperties(cellularLp);
b.expectBroadcast();
}
@@ -12442,66 +12393,64 @@
.build();
mCm.registerNetworkCallback(allNetworksRequest, allNetworksCb);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true /* validated */);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true /* validated */);
- mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- allNetworksCb.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ allNetworksCb.expectAvailableThenValidatedCallbacks(mCellAgent);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true /* validated */);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true /* validated */);
- mDefaultNetworkCallback.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
+ mDefaultNetworkCallback.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
// While the default callback doesn't see the network before it's validated, the listen
// sees the network come up and validate later
- allNetworksCb.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
- allNetworksCb.expectLosing(mCellNetworkAgent);
- allNetworksCb.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
- allNetworksCb.expect(LOST, mCellNetworkAgent,
- TEST_LINGER_DELAY_MS * 2);
+ allNetworksCb.expectAvailableCallbacksUnvalidated(mWiFiAgent);
+ allNetworksCb.expectLosing(mCellAgent);
+ allNetworksCb.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ allNetworksCb.expect(LOST, mCellAgent, TEST_LINGER_DELAY_MS * 2);
// The cell network has disconnected (see LOST above) because it was outscored and
// had no requests (see setAlwaysOnNetworks(false) above)
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
final NetworkScore score = new NetworkScore.Builder().setLegacyInt(30).build();
- mCellNetworkAgent.setScore(score);
- mCellNetworkAgent.connect(false /* validated */);
+ mCellAgent.setScore(score);
+ mCellAgent.connect(false /* validated */);
// The cell network gets torn down right away.
- allNetworksCb.expectAvailableCallbacksUnvalidated(mCellNetworkAgent);
- allNetworksCb.expect(LOST, mCellNetworkAgent,
- TEST_NASCENT_DELAY_MS * 2);
+ allNetworksCb.expectAvailableCallbacksUnvalidated(mCellAgent);
+ allNetworksCb.expect(LOST, mCellAgent, TEST_NASCENT_DELAY_MS * 2);
allNetworksCb.assertNoCallback();
// Now create a cell network with KEEP_CONNECTED_FOR_HANDOVER and make sure it's
// not disconnected immediately when outscored.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
final NetworkScore scoreKeepup = new NetworkScore.Builder().setLegacyInt(30)
.setKeepConnectedReason(KEEP_CONNECTED_FOR_HANDOVER).build();
- mCellNetworkAgent.setScore(scoreKeepup);
- mCellNetworkAgent.connect(true /* validated */);
+ mCellAgent.setScore(scoreKeepup);
+ mCellAgent.connect(true /* validated */);
- allNetworksCb.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ allNetworksCb.expectAvailableThenValidatedCallbacks(mCellAgent);
mDefaultNetworkCallback.assertNoCallback();
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
- allNetworksCb.expect(LOST, mWiFiNetworkAgent);
- mDefaultNetworkCallback.expect(LOST, mWiFiNetworkAgent);
- mDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ allNetworksCb.expect(LOST, mWiFiAgent);
+ mDefaultNetworkCallback.expect(LOST, mWiFiAgent);
+ mDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellAgent);
// Reconnect a WiFi network and make sure the cell network is still not torn down.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true /* validated */);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true /* validated */);
- allNetworksCb.expectAvailableThenValidatedCallbacks(mWiFiNetworkAgent);
- mDefaultNetworkCallback.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
+ allNetworksCb.expectAvailableThenValidatedCallbacks(mWiFiAgent);
+ mDefaultNetworkCallback.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
// Now remove the reason to keep connected and make sure the network lingers and is
// torn down.
- mCellNetworkAgent.setScore(new NetworkScore.Builder().setLegacyInt(30).build());
- allNetworksCb.expectLosing(mCellNetworkAgent, TEST_NASCENT_DELAY_MS * 2);
- allNetworksCb.expect(LOST, mCellNetworkAgent, TEST_LINGER_DELAY_MS * 2);
+ mCellAgent.setScore(new NetworkScore.Builder().setLegacyInt(30).build());
+ allNetworksCb.expectLosing(mCellAgent, TEST_NASCENT_DELAY_MS * 2);
+ allNetworksCb.expect(LOST, mCellAgent, TEST_LINGER_DELAY_MS * 2);
mDefaultNetworkCallback.assertNoCallback();
mCm.unregisterNetworkCallback(allNetworksCb);
@@ -12519,21 +12468,21 @@
mFilter = mock(QosFilter.class);
// Ensure the network is disconnected before anything else occurs
- assertNull(mCellNetworkAgent);
+ assertNull(mCellAgent);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
verifyActiveNetwork(TRANSPORT_CELLULAR);
waitForIdle();
- final Network network = mCellNetworkAgent.getNetwork();
+ final Network network = mCellAgent.getNetwork();
final Pair<IQosCallback, IBinder> pair = createQosCallback();
mCallback = pair.first;
doReturn(network).when(mFilter).getNetwork();
doReturn(QosCallbackException.EX_TYPE_FILTER_NONE).when(mFilter).validate();
- mAgentWrapper = mCellNetworkAgent;
+ mAgentWrapper = mCellAgent;
}
void registerQosCallback(@NonNull final QosFilter filter,
@@ -13123,12 +13072,12 @@
// Corresponds to a metered cellular network. Will be used for the default network.
case TRANSPORT_CELLULAR:
if (!connectAgent) {
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
break;
}
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.removeCapability(NET_CAPABILITY_NOT_METERED);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.removeCapability(NET_CAPABILITY_NOT_METERED);
+ mCellAgent.connect(true);
break;
// Corresponds to a restricted ethernet network with OEM_PAID/OEM_PRIVATE.
case TRANSPORT_ETHERNET:
@@ -13141,12 +13090,12 @@
// Corresponds to unmetered Wi-Fi.
case TRANSPORT_WIFI:
if (!connectAgent) {
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
break;
}
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.addCapability(NET_CAPABILITY_NOT_METERED);
+ mWiFiAgent.connect(true);
break;
default:
throw new AssertionError("Unsupported transport type passed in.");
@@ -13156,15 +13105,15 @@
}
private void startOemManagedNetwork(final boolean isOemPaid) throws Exception {
- mEthernetNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_ETHERNET);
- mEthernetNetworkAgent.addCapability(
+ mEthernetAgent = new TestNetworkAgentWrapper(TRANSPORT_ETHERNET);
+ mEthernetAgent.addCapability(
isOemPaid ? NET_CAPABILITY_OEM_PAID : NET_CAPABILITY_OEM_PRIVATE);
- mEthernetNetworkAgent.removeCapability(NET_CAPABILITY_NOT_RESTRICTED);
- mEthernetNetworkAgent.connect(true);
+ mEthernetAgent.removeCapability(NET_CAPABILITY_NOT_RESTRICTED);
+ mEthernetAgent.connect(true);
}
private void stopOemManagedNetwork() {
- mEthernetNetworkAgent.disconnect();
+ mEthernetAgent.disconnect();
waitForIdle();
}
@@ -13397,7 +13346,7 @@
setOemNetworkPreferenceAgentConnected(TRANSPORT_ETHERNET, true);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
null,
- mEthernetNetworkAgent.getNetwork());
+ mEthernetAgent.getNetwork());
// Verify that the active network is correct
verifyActiveNetwork(TRANSPORT_ETHERNET);
@@ -13418,16 +13367,16 @@
assertTrue(mCm.isActiveNetworkMetered());
// Connect to an unmetered restricted network that will only be available to the OEM pref.
- mEthernetNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_ETHERNET);
- mEthernetNetworkAgent.addCapability(NET_CAPABILITY_OEM_PAID);
- mEthernetNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
- mEthernetNetworkAgent.removeCapability(NET_CAPABILITY_NOT_RESTRICTED);
- mEthernetNetworkAgent.connect(true);
+ mEthernetAgent = new TestNetworkAgentWrapper(TRANSPORT_ETHERNET);
+ mEthernetAgent.addCapability(NET_CAPABILITY_OEM_PAID);
+ mEthernetAgent.addCapability(NET_CAPABILITY_NOT_METERED);
+ mEthernetAgent.removeCapability(NET_CAPABILITY_NOT_RESTRICTED);
+ mEthernetAgent.connect(true);
waitForIdle();
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
null,
- mEthernetNetworkAgent.getNetwork());
+ mEthernetAgent.getNetwork());
assertFalse(mCm.isActiveNetworkMetered());
// default NCs will be unregistered in tearDown
@@ -13458,19 +13407,18 @@
setOemNetworkPreferenceAgentConnected(TRANSPORT_ETHERNET, true);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
null,
- mEthernetNetworkAgent.getNetwork());
+ mEthernetAgent.getNetwork());
// At this point with a restricted network used, the available callback should trigger.
- defaultNetworkCallback.expectAvailableThenValidatedCallbacks(mEthernetNetworkAgent);
- assertEquals(defaultNetworkCallback.getLastAvailableNetwork(),
- mEthernetNetworkAgent.getNetwork());
+ defaultNetworkCallback.expectAvailableThenValidatedCallbacks(mEthernetAgent);
+ assertEquals(defaultNetworkCallback.getLastAvailableNetwork(), mEthernetAgent.getNetwork());
otherUidDefaultCallback.assertNoCallback();
// Now bring down the default network which should trigger a LOST callback.
setOemNetworkPreferenceAgentConnected(TRANSPORT_ETHERNET, false);
// At this point, with no network is available, the lost callback should trigger
- defaultNetworkCallback.expect(LOST, mEthernetNetworkAgent);
+ defaultNetworkCallback.expect(LOST, mEthernetAgent);
otherUidDefaultCallback.assertNoCallback();
// Confirm we can unregister without issues.
@@ -13503,12 +13451,11 @@
setOemNetworkPreferenceAgentConnected(TRANSPORT_ETHERNET, true);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
null,
- mEthernetNetworkAgent.getNetwork());
+ mEthernetAgent.getNetwork());
// At this point with a restricted network used, the available callback should trigger
- defaultNetworkCallback.expectAvailableThenValidatedCallbacks(mEthernetNetworkAgent);
- assertEquals(defaultNetworkCallback.getLastAvailableNetwork(),
- mEthernetNetworkAgent.getNetwork());
+ defaultNetworkCallback.expectAvailableThenValidatedCallbacks(mEthernetAgent);
+ assertEquals(defaultNetworkCallback.getLastAvailableNetwork(), mEthernetAgent.getNetwork());
otherUidDefaultCallback.assertNoCallback();
// Now bring down the default network which should trigger a LOST callback.
@@ -13516,7 +13463,7 @@
otherUidDefaultCallback.assertNoCallback();
// At this point, with no network is available, the lost callback should trigger
- defaultNetworkCallback.expect(LOST, mEthernetNetworkAgent);
+ defaultNetworkCallback.expect(LOST, mEthernetAgent);
otherUidDefaultCallback.assertNoCallback();
// Confirm we can unregister without issues.
@@ -13549,27 +13496,26 @@
setOemNetworkPreferenceAgentConnected(TRANSPORT_ETHERNET, true);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
null,
- mEthernetNetworkAgent.getNetwork());
+ mEthernetAgent.getNetwork());
// As this callback does not have access to the OEM_PAID network, it will not fire.
defaultNetworkCallback.assertNoCallback();
assertDefaultNetworkCapabilities(userId /* no networks */);
// The other UID does have access, and gets a callback.
- otherUidDefaultCallback.expectAvailableThenValidatedCallbacks(mEthernetNetworkAgent);
+ otherUidDefaultCallback.expectAvailableThenValidatedCallbacks(mEthernetAgent);
// Bring up unrestricted cellular. This should now satisfy the default network.
setOemNetworkPreferenceAgentConnected(TRANSPORT_CELLULAR, true);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mCellNetworkAgent.getNetwork(),
- mEthernetNetworkAgent.getNetwork());
+ mCellAgent.getNetwork(),
+ mEthernetAgent.getNetwork());
// At this point with an unrestricted network used, the available callback should trigger
// The other UID is unaffected and remains on the paid network.
- defaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- assertEquals(defaultNetworkCallback.getLastAvailableNetwork(),
- mCellNetworkAgent.getNetwork());
- assertDefaultNetworkCapabilities(userId, mCellNetworkAgent);
+ defaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ assertEquals(defaultNetworkCallback.getLastAvailableNetwork(), mCellAgent.getNetwork());
+ assertDefaultNetworkCapabilities(userId, mCellAgent);
otherUidDefaultCallback.assertNoCallback();
// Now bring down the per-app network.
@@ -13578,13 +13524,13 @@
// Since the callback didn't use the per-app network, only the other UID gets a callback.
// Because the preference specifies no fallback, it does not switch to cellular.
defaultNetworkCallback.assertNoCallback();
- otherUidDefaultCallback.expect(LOST, mEthernetNetworkAgent);
+ otherUidDefaultCallback.expect(LOST, mEthernetAgent);
// Now bring down the default network.
setOemNetworkPreferenceAgentConnected(TRANSPORT_CELLULAR, false);
// As this callback was tracking the default, this should now trigger.
- defaultNetworkCallback.expect(LOST, mCellNetworkAgent);
+ defaultNetworkCallback.expect(LOST, mCellAgent);
otherUidDefaultCallback.assertNoCallback();
// Confirm we can unregister without issues.
@@ -13737,22 +13683,22 @@
// Bring up metered cellular. This will satisfy the fallback network.
setOemNetworkPreferenceAgentConnected(TRANSPORT_CELLULAR, true);
verifySetOemNetworkPreferenceForPreference(uidRanges,
- mCellNetworkAgent.getNetwork().netId, 1 /* times */,
+ mCellAgent.getNetwork().netId, 1 /* times */,
OEM_PREF_ANY_NET_ID, 0 /* times */,
false /* shouldDestroyNetwork */);
// Bring up ethernet with OEM_PAID. This will satisfy NET_CAPABILITY_OEM_PAID.
setOemNetworkPreferenceAgentConnected(TRANSPORT_ETHERNET, true);
verifySetOemNetworkPreferenceForPreference(uidRanges,
- mEthernetNetworkAgent.getNetwork().netId, 1 /* times */,
- mCellNetworkAgent.getNetwork().netId, 1 /* times */,
+ mEthernetAgent.getNetwork().netId, 1 /* times */,
+ mCellAgent.getNetwork().netId, 1 /* times */,
false /* shouldDestroyNetwork */);
// Bring up unmetered Wi-Fi. This will satisfy NET_CAPABILITY_NOT_METERED.
setOemNetworkPreferenceAgentConnected(TRANSPORT_WIFI, true);
verifySetOemNetworkPreferenceForPreference(uidRanges,
- mWiFiNetworkAgent.getNetwork().netId, 1 /* times */,
- mEthernetNetworkAgent.getNetwork().netId, 1 /* times */,
+ mWiFiAgent.getNetwork().netId, 1 /* times */,
+ mEthernetAgent.getNetwork().netId, 1 /* times */,
false /* shouldDestroyNetwork */);
// Disconnecting OEM_PAID should have no effect as it is lower in priority then unmetered.
@@ -13766,15 +13712,15 @@
// Disconnecting unmetered should put PANS on lowest priority fallback request.
setOemNetworkPreferenceAgentConnected(TRANSPORT_WIFI, false);
verifySetOemNetworkPreferenceForPreference(uidRanges,
- mCellNetworkAgent.getNetwork().netId, 1 /* times */,
- mWiFiNetworkAgent.getNetwork().netId, 0 /* times */,
+ mCellAgent.getNetwork().netId, 1 /* times */,
+ mWiFiAgent.getNetwork().netId, 0 /* times */,
true /* shouldDestroyNetwork */);
// Disconnecting the fallback network should result in no connectivity.
setOemNetworkPreferenceAgentConnected(TRANSPORT_CELLULAR, false);
verifySetOemNetworkPreferenceForPreference(uidRanges,
OEM_PREF_ANY_NET_ID, 0 /* times */,
- mCellNetworkAgent.getNetwork().netId, 0 /* times */,
+ mCellAgent.getNetwork().netId, 0 /* times */,
true /* shouldDestroyNetwork */);
}
@@ -13812,22 +13758,22 @@
// Bring up ethernet with OEM_PAID. This will satisfy NET_CAPABILITY_OEM_PAID.
setOemNetworkPreferenceAgentConnected(TRANSPORT_ETHERNET, true);
verifySetOemNetworkPreferenceForPreference(uidRanges,
- mEthernetNetworkAgent.getNetwork().netId, 1 /* times */,
+ mEthernetAgent.getNetwork().netId, 1 /* times */,
mService.mNoServiceNetwork.network.getNetId(), 1 /* times */,
false /* shouldDestroyNetwork */);
// Bring up unmetered Wi-Fi. This will satisfy NET_CAPABILITY_NOT_METERED.
setOemNetworkPreferenceAgentConnected(TRANSPORT_WIFI, true);
verifySetOemNetworkPreferenceForPreference(uidRanges,
- mWiFiNetworkAgent.getNetwork().netId, 1 /* times */,
- mEthernetNetworkAgent.getNetwork().netId, 1 /* times */,
+ mWiFiAgent.getNetwork().netId, 1 /* times */,
+ mEthernetAgent.getNetwork().netId, 1 /* times */,
false /* shouldDestroyNetwork */);
// Disconnecting unmetered should put PANS on OEM_PAID.
setOemNetworkPreferenceAgentConnected(TRANSPORT_WIFI, false);
verifySetOemNetworkPreferenceForPreference(uidRanges,
- mEthernetNetworkAgent.getNetwork().netId, 1 /* times */,
- mWiFiNetworkAgent.getNetwork().netId, 0 /* times */,
+ mEthernetAgent.getNetwork().netId, 1 /* times */,
+ mWiFiAgent.getNetwork().netId, 0 /* times */,
true /* shouldDestroyNetwork */);
// Disconnecting OEM_PAID should result in no connectivity.
@@ -13835,7 +13781,7 @@
setOemNetworkPreferenceAgentConnected(TRANSPORT_ETHERNET, false);
verifySetOemNetworkPreferenceForPreference(uidRanges,
mService.mNoServiceNetwork.network.getNetId(), 1 /* times */,
- mEthernetNetworkAgent.getNetwork().netId, 0 /* times */,
+ mEthernetAgent.getNetwork().netId, 0 /* times */,
true /* shouldDestroyNetwork */);
}
@@ -13879,7 +13825,7 @@
// Bring up ethernet with OEM_PAID. This will satisfy NET_CAPABILITY_OEM_PAID.
setOemNetworkPreferenceAgentConnected(TRANSPORT_ETHERNET, true);
verifySetOemNetworkPreferenceForPreference(uidRanges,
- mEthernetNetworkAgent.getNetwork().netId, 1 /* times */,
+ mEthernetAgent.getNetwork().netId, 1 /* times */,
mService.mNoServiceNetwork.network.getNetId(), 1 /* times */,
false /* shouldDestroyNetwork */);
@@ -13887,7 +13833,7 @@
setOemNetworkPreferenceAgentConnected(TRANSPORT_ETHERNET, false);
verifySetOemNetworkPreferenceForPreference(uidRanges,
mService.mNoServiceNetwork.network.getNetId(), 1 /* times */,
- mEthernetNetworkAgent.getNetwork().netId, 0 /* times */,
+ mEthernetAgent.getNetwork().netId, 0 /* times */,
true /* shouldDestroyNetwork */);
}
@@ -13931,7 +13877,7 @@
// Bring up ethernet with OEM_PRIVATE. This will satisfy NET_CAPABILITY_OEM_PRIVATE.
startOemManagedNetwork(false);
verifySetOemNetworkPreferenceForPreference(uidRanges,
- mEthernetNetworkAgent.getNetwork().netId, 1 /* times */,
+ mEthernetAgent.getNetwork().netId, 1 /* times */,
mService.mNoServiceNetwork.network.getNetId(), 1 /* times */,
false /* shouldDestroyNetwork */);
@@ -13939,7 +13885,7 @@
stopOemManagedNetwork();
verifySetOemNetworkPreferenceForPreference(uidRanges,
mService.mNoServiceNetwork.network.getNetId(), 1 /* times */,
- mEthernetNetworkAgent.getNetwork().netId, 0 /* times */,
+ mEthernetAgent.getNetwork().netId, 0 /* times */,
true /* shouldDestroyNetwork */);
}
@@ -13972,7 +13918,7 @@
// Test that we correctly add the expected values for multiple users.
setOemNetworkPreferenceAgentConnected(TRANSPORT_CELLULAR, true);
verifySetOemNetworkPreferenceForPreference(uidRanges,
- mCellNetworkAgent.getNetwork().netId, 1 /* times */,
+ mCellAgent.getNetwork().netId, 1 /* times */,
OEM_PREF_ANY_NET_ID, 0 /* times */,
false /* shouldDestroyNetwork */);
@@ -13980,7 +13926,7 @@
setOemNetworkPreferenceAgentConnected(TRANSPORT_CELLULAR, false);
verifySetOemNetworkPreferenceForPreference(uidRanges,
OEM_PREF_ANY_NET_ID, 0 /* times */,
- mCellNetworkAgent.getNetwork().netId, 0 /* times */,
+ mCellAgent.getNetwork().netId, 0 /* times */,
true /* shouldDestroyNetwork */);
}
@@ -14015,7 +13961,7 @@
// Test that we correctly add the expected values for multiple users.
setOemNetworkPreferenceAgentConnected(TRANSPORT_CELLULAR, true);
verifySetOemNetworkPreferenceForPreference(uidRangesSingleUser,
- mCellNetworkAgent.getNetwork().netId, 1 /* times */,
+ mCellAgent.getNetwork().netId, 1 /* times */,
OEM_PREF_ANY_NET_ID, 0 /* times */,
false /* shouldDestroyNetwork */);
@@ -14028,8 +13974,8 @@
// Test that we correctly add values for all users and remove for the single user.
verifySetOemNetworkPreferenceForPreference(uidRangesBothUsers, uidRangesSingleUser,
- mCellNetworkAgent.getNetwork().netId, 1 /* times */,
- mCellNetworkAgent.getNetwork().netId, 1 /* times */,
+ mCellAgent.getNetwork().netId, 1 /* times */,
+ mCellAgent.getNetwork().netId, 1 /* times */,
false /* shouldDestroyNetwork */);
// Send a broadcast indicating a user was removed.
@@ -14040,8 +13986,8 @@
// Test that we correctly add values for the single user and remove for the all users.
verifySetOemNetworkPreferenceForPreference(uidRangesSingleUser, uidRangesBothUsers,
- mCellNetworkAgent.getNetwork().netId, 1 /* times */,
- mCellNetworkAgent.getNetwork().netId, 1 /* times */,
+ mCellAgent.getNetwork().netId, 1 /* times */,
+ mCellAgent.getNetwork().netId, 1 /* times */,
false /* shouldDestroyNetwork */);
}
@@ -14071,7 +14017,7 @@
// Test that we correctly add the expected values for installed packages.
setOemNetworkPreferenceAgentConnected(TRANSPORT_CELLULAR, true);
verifySetOemNetworkPreferenceForPreference(uidRangesSinglePackage,
- mCellNetworkAgent.getNetwork().netId, 1 /* times */,
+ mCellAgent.getNetwork().netId, 1 /* times */,
OEM_PREF_ANY_NET_ID, 0 /* times */,
false /* shouldDestroyNetwork */);
@@ -14087,8 +14033,8 @@
// Test the single package is removed and the combined packages are added.
verifySetOemNetworkPreferenceForPreference(uidRangesAllPackages, uidRangesSinglePackage,
- mCellNetworkAgent.getNetwork().netId, 1 /* times */,
- mCellNetworkAgent.getNetwork().netId, 1 /* times */,
+ mCellAgent.getNetwork().netId, 1 /* times */,
+ mCellAgent.getNetwork().netId, 1 /* times */,
false /* shouldDestroyNetwork */);
// Set the system to no longer recognize the package to be installed
@@ -14101,8 +14047,8 @@
// Test the combined packages are removed and the single package is added.
verifySetOemNetworkPreferenceForPreference(uidRangesSinglePackage, uidRangesAllPackages,
- mCellNetworkAgent.getNetwork().netId, 1 /* times */,
- mCellNetworkAgent.getNetwork().netId, 1 /* times */,
+ mCellAgent.getNetwork().netId, 1 /* times */,
+ mCellAgent.getNetwork().netId, 1 /* times */,
false /* shouldDestroyNetwork */);
// Set the system to change the installed package's uid
@@ -14118,8 +14064,8 @@
// Test the original uid is removed and is replaced with the new uid.
verifySetOemNetworkPreferenceForPreference(uidRangesReplacedPackage, uidRangesSinglePackage,
- mCellNetworkAgent.getNetwork().netId, 1 /* times */,
- mCellNetworkAgent.getNetwork().netId, 1 /* times */,
+ mCellAgent.getNetwork().netId, 1 /* times */,
+ mCellAgent.getNetwork().netId, 1 /* times */,
false /* shouldDestroyNetwork */);
}
@@ -14144,32 +14090,32 @@
// Bring up metered cellular. This will satisfy the fallback network.
setOemNetworkPreferenceAgentConnected(TRANSPORT_CELLULAR, true);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mCellNetworkAgent.getNetwork(),
- mCellNetworkAgent.getNetwork());
+ mCellAgent.getNetwork(),
+ mCellAgent.getNetwork());
// Bring up ethernet with OEM_PAID. This will satisfy NET_CAPABILITY_OEM_PAID.
setOemNetworkPreferenceAgentConnected(TRANSPORT_ETHERNET, true);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mCellNetworkAgent.getNetwork(),
- mEthernetNetworkAgent.getNetwork());
+ mCellAgent.getNetwork(),
+ mEthernetAgent.getNetwork());
// Bring up unmetered Wi-Fi. This will satisfy NET_CAPABILITY_NOT_METERED.
setOemNetworkPreferenceAgentConnected(TRANSPORT_WIFI, true);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mWiFiNetworkAgent.getNetwork(),
- mWiFiNetworkAgent.getNetwork());
+ mWiFiAgent.getNetwork(),
+ mWiFiAgent.getNetwork());
// Disconnecting unmetered Wi-Fi will put the pref on OEM_PAID and fallback on cellular.
setOemNetworkPreferenceAgentConnected(TRANSPORT_WIFI, false);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mCellNetworkAgent.getNetwork(),
- mEthernetNetworkAgent.getNetwork());
+ mCellAgent.getNetwork(),
+ mEthernetAgent.getNetwork());
// Disconnecting cellular should keep OEM network on OEM_PAID and fallback will be null.
setOemNetworkPreferenceAgentConnected(TRANSPORT_CELLULAR, false);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
null,
- mEthernetNetworkAgent.getNetwork());
+ mEthernetAgent.getNetwork());
// Disconnecting OEM_PAID will put both on null as it is the last network.
setOemNetworkPreferenceAgentConnected(TRANSPORT_ETHERNET, false);
@@ -14217,8 +14163,8 @@
oemPaidFactory.register();
oemPaidFactory.expectRequestAdd(); // Because nobody satisfies the request
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
// A network connected that satisfies the default internet request. For the OEM_PAID
// preference, this is not as good as an OEM_PAID network, so even if the score of
@@ -14253,7 +14199,7 @@
expectNoRequestChanged(internetFactory);
internetFactory.assertRequestCountEquals(0);
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
// The network satisfying the default internet request has disconnected, so the
// internetFactory sees the default request again. However there is a network with OEM_PAID
// connected, so the 2nd OEM_PAID req is already satisfied, so the oemPaidFactory doesn't
@@ -14264,8 +14210,8 @@
internetFactory.assertRequestCountEquals(1);
// Cell connects again, still with score 50. Back to the previous state.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
expectNoRequestChanged(oemPaidFactory);
oemPaidFactory.assertRequestCountEquals(1);
internetFactory.expectRequestRemove();
@@ -14277,18 +14223,18 @@
wifiCallback);
// Now WiFi connects and it's unmetered, but it's weaker than cell.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
- mWiFiNetworkAgent.setScore(new NetworkScore.Builder().setLegacyInt(30).setExiting(true)
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.addCapability(NET_CAPABILITY_NOT_METERED);
+ mWiFiAgent.setScore(new NetworkScore.Builder().setLegacyInt(30).setExiting(true)
.build()); // Not the best Internet network, but unmetered
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent.connect(true);
// The OEM_PAID preference prefers an unmetered network to an OEM_PAID network, so
// the oemPaidFactory can't beat wifi no matter how high its score.
oemPaidFactory.expectRequestRemove();
expectNoRequestChanged(internetFactory);
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
// Now that the best internet network (cell, with its 50 score compared to 30 for WiFi
// at this point), the default internet request is satisfied by a network worse than
// the internetFactory announced, so it gets the request. However, there is still an
@@ -14319,32 +14265,32 @@
// Bring up metered cellular. This will satisfy the fallback network but not the pref.
setOemNetworkPreferenceAgentConnected(TRANSPORT_CELLULAR, true);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mCellNetworkAgent.getNetwork(),
+ mCellAgent.getNetwork(),
mService.mNoServiceNetwork.network());
// Bring up ethernet with OEM_PAID. This will satisfy NET_CAPABILITY_OEM_PAID.
setOemNetworkPreferenceAgentConnected(TRANSPORT_ETHERNET, true);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mCellNetworkAgent.getNetwork(),
- mEthernetNetworkAgent.getNetwork());
+ mCellAgent.getNetwork(),
+ mEthernetAgent.getNetwork());
// Bring up unmetered Wi-Fi. This will satisfy NET_CAPABILITY_NOT_METERED.
setOemNetworkPreferenceAgentConnected(TRANSPORT_WIFI, true);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mWiFiNetworkAgent.getNetwork(),
- mWiFiNetworkAgent.getNetwork());
+ mWiFiAgent.getNetwork(),
+ mWiFiAgent.getNetwork());
// Disconnecting unmetered Wi-Fi will put the OEM pref on OEM_PAID and fallback on cellular.
setOemNetworkPreferenceAgentConnected(TRANSPORT_WIFI, false);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mCellNetworkAgent.getNetwork(),
- mEthernetNetworkAgent.getNetwork());
+ mCellAgent.getNetwork(),
+ mEthernetAgent.getNetwork());
// Disconnecting cellular should keep OEM network on OEM_PAID and fallback will be null.
setOemNetworkPreferenceAgentConnected(TRANSPORT_CELLULAR, false);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
null,
- mEthernetNetworkAgent.getNetwork());
+ mEthernetAgent.getNetwork());
// Disconnecting OEM_PAID puts the fallback on null and the pref on the disconnected net.
setOemNetworkPreferenceAgentConnected(TRANSPORT_ETHERNET, false);
@@ -14377,32 +14323,32 @@
// Bring up metered cellular. This will satisfy the fallback network.
setOemNetworkPreferenceAgentConnected(TRANSPORT_CELLULAR, true);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mCellNetworkAgent.getNetwork(),
+ mCellAgent.getNetwork(),
mService.mNoServiceNetwork.network());
// Bring up ethernet with OEM_PAID. This will satisfy NET_CAPABILITY_OEM_PAID.
setOemNetworkPreferenceAgentConnected(TRANSPORT_ETHERNET, true);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mCellNetworkAgent.getNetwork(),
- mEthernetNetworkAgent.getNetwork());
+ mCellAgent.getNetwork(),
+ mEthernetAgent.getNetwork());
// Bring up unmetered Wi-Fi. The OEM network shouldn't change, the fallback will take Wi-Fi.
setOemNetworkPreferenceAgentConnected(TRANSPORT_WIFI, true);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mWiFiNetworkAgent.getNetwork(),
- mEthernetNetworkAgent.getNetwork());
+ mWiFiAgent.getNetwork(),
+ mEthernetAgent.getNetwork());
// Disconnecting unmetered Wi-Fi shouldn't change the OEM network with fallback on cellular.
setOemNetworkPreferenceAgentConnected(TRANSPORT_WIFI, false);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mCellNetworkAgent.getNetwork(),
- mEthernetNetworkAgent.getNetwork());
+ mCellAgent.getNetwork(),
+ mEthernetAgent.getNetwork());
// Disconnecting OEM_PAID will keep the fallback on cellular and nothing for OEM_PAID.
// OEM_PAID_ONLY not supporting a fallback now uses the disconnected network.
setOemNetworkPreferenceAgentConnected(TRANSPORT_ETHERNET, false);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mCellNetworkAgent.getNetwork(),
+ mCellAgent.getNetwork(),
mService.mNoServiceNetwork.network());
// Disconnecting cellular will put the fallback on null and the pref on disconnected.
@@ -14436,32 +14382,32 @@
// Bring up metered cellular. This will satisfy the fallback network.
setOemNetworkPreferenceAgentConnected(TRANSPORT_CELLULAR, true);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mCellNetworkAgent.getNetwork(),
+ mCellAgent.getNetwork(),
mService.mNoServiceNetwork.network());
// Bring up ethernet with OEM_PRIVATE. This will satisfy NET_CAPABILITY_OEM_PRIVATE.
startOemManagedNetwork(false);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mCellNetworkAgent.getNetwork(),
- mEthernetNetworkAgent.getNetwork());
+ mCellAgent.getNetwork(),
+ mEthernetAgent.getNetwork());
// Bring up unmetered Wi-Fi. The OEM network shouldn't change, the fallback will take Wi-Fi.
setOemNetworkPreferenceAgentConnected(TRANSPORT_WIFI, true);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mWiFiNetworkAgent.getNetwork(),
- mEthernetNetworkAgent.getNetwork());
+ mWiFiAgent.getNetwork(),
+ mEthernetAgent.getNetwork());
// Disconnecting unmetered Wi-Fi shouldn't change the OEM network with fallback on cellular.
setOemNetworkPreferenceAgentConnected(TRANSPORT_WIFI, false);
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mCellNetworkAgent.getNetwork(),
- mEthernetNetworkAgent.getNetwork());
+ mCellAgent.getNetwork(),
+ mEthernetAgent.getNetwork());
// Disconnecting OEM_PRIVATE will keep the fallback on cellular.
// OEM_PRIVATE_ONLY not supporting a fallback now uses to the disconnected network.
stopOemManagedNetwork();
verifyMultipleDefaultNetworksTracksCorrectly(expectedOemPrefRequestSize,
- mCellNetworkAgent.getNetwork(),
+ mCellAgent.getNetwork(),
mService.mNoServiceNetwork.network());
// Disconnecting cellular will put the fallback on null and pref on disconnected.
@@ -14482,13 +14428,13 @@
setOemNetworkPreferenceAgentConnected(TRANSPORT_CELLULAR, true);
- mSystemDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mSystemDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
- mCellNetworkAgent.addCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED);
- mSystemDefaultNetworkCallback.expectCapabilitiesThat(mCellNetworkAgent, nc ->
+ mCellAgent.addCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED);
+ mSystemDefaultNetworkCallback.expectCapabilitiesThat(mCellAgent, nc ->
nc.hasCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED));
- mDefaultNetworkCallback.expectCapabilitiesThat(mCellNetworkAgent, nc ->
+ mDefaultNetworkCallback.expectCapabilitiesThat(mCellAgent, nc ->
nc.hasCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED));
// default callbacks will be unregistered in tearDown
@@ -14543,29 +14489,29 @@
final TestNetworkCallback cellCb = new TestNetworkCallback();
mCm.requestNetwork(new NetworkRequest.Builder().addCapability(NET_CAPABILITY_MMS).build(),
cellCb);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp, cellNcTemplate);
- mCellNetworkAgent.connect(true);
- cellCb.expectAvailableCallbacksUnvalidated(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp, cellNcTemplate);
+ mCellAgent.connect(true);
+ cellCb.expectAvailableCallbacksUnvalidated(mCellAgent);
List<NetworkStateSnapshot> snapshots = mCm.getAllNetworkStateSnapshots();
assertLength(1, snapshots);
// Compose the expected cellular snapshot for verification.
final NetworkCapabilities cellNc =
- mCm.getNetworkCapabilities(mCellNetworkAgent.getNetwork());
+ mCm.getNetworkCapabilities(mCellAgent.getNetwork());
final NetworkStateSnapshot cellSnapshot = new NetworkStateSnapshot(
- mCellNetworkAgent.getNetwork(), cellNc, cellLp,
+ mCellAgent.getNetwork(), cellNc, cellLp,
null, ConnectivityManager.TYPE_MOBILE);
assertEquals(cellSnapshot, snapshots.get(0));
// Connect wifi and verify the snapshots.
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
waitForIdle();
// Compose the expected wifi snapshot for verification.
final NetworkCapabilities wifiNc =
- mCm.getNetworkCapabilities(mWiFiNetworkAgent.getNetwork());
+ mCm.getNetworkCapabilities(mWiFiAgent.getNetwork());
final NetworkStateSnapshot wifiSnapshot = new NetworkStateSnapshot(
- mWiFiNetworkAgent.getNetwork(), wifiNc, new LinkProperties(), null,
+ mWiFiAgent.getNetwork(), wifiNc, new LinkProperties(), null,
ConnectivityManager.TYPE_WIFI);
snapshots = mCm.getAllNetworkStateSnapshots();
@@ -14573,33 +14519,33 @@
assertContainsAll(snapshots, cellSnapshot, wifiSnapshot);
// Set cellular as suspended, verify the snapshots will contain suspended networks.
- mCellNetworkAgent.suspend();
+ mCellAgent.suspend();
waitForIdle();
final NetworkCapabilities cellSuspendedNc =
- mCm.getNetworkCapabilities(mCellNetworkAgent.getNetwork());
+ mCm.getNetworkCapabilities(mCellAgent.getNetwork());
assertFalse(cellSuspendedNc.hasCapability(NET_CAPABILITY_NOT_SUSPENDED));
final NetworkStateSnapshot cellSuspendedSnapshot = new NetworkStateSnapshot(
- mCellNetworkAgent.getNetwork(), cellSuspendedNc, cellLp,
+ mCellAgent.getNetwork(), cellSuspendedNc, cellLp,
null, ConnectivityManager.TYPE_MOBILE);
snapshots = mCm.getAllNetworkStateSnapshots();
assertLength(2, snapshots);
assertContainsAll(snapshots, cellSuspendedSnapshot, wifiSnapshot);
// Disconnect wifi, verify the snapshots contain only cellular.
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
waitForIdle();
snapshots = mCm.getAllNetworkStateSnapshots();
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
assertLength(1, snapshots);
assertEquals(cellSuspendedSnapshot, snapshots.get(0));
- mCellNetworkAgent.resume();
+ mCellAgent.resume();
waitForIdle();
snapshots = mCm.getAllNetworkStateSnapshots();
assertLength(1, snapshots);
assertEquals(cellSnapshot, snapshots.get(0));
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
waitForIdle();
verifyNoNetwork();
mCm.unregisterNetworkCallback(cellCb);
@@ -14670,35 +14616,35 @@
new NetworkRequest.Builder().addCapability(NET_CAPABILITY_TRUSTED).build(),
bestMatchingCb, mCsHandlerThread.getThreadHandler());
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- bestMatchingCb.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ bestMatchingCb.expectAvailableThenValidatedCallbacks(mCellAgent);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
- bestMatchingCb.expectAvailableDoubleValidatedCallbacks(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
+ bestMatchingCb.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
// Change something on cellular to trigger capabilities changed, since the callback
// only cares about the best network, verify it received nothing from cellular.
- mCellNetworkAgent.addCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED);
+ mCellAgent.addCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED);
bestMatchingCb.assertNoCallback();
// Make cellular the best network again, verify the callback now tracks cellular.
- mWiFiNetworkAgent.adjustScore(-50);
- bestMatchingCb.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ mWiFiAgent.adjustScore(-50);
+ bestMatchingCb.expectAvailableCallbacksValidated(mCellAgent);
// Make cellular temporary non-trusted, which will not satisfying the request.
// Verify the callback switch from/to the other network accordingly.
- mCellNetworkAgent.removeCapability(NET_CAPABILITY_TRUSTED);
- bestMatchingCb.expectAvailableCallbacksValidated(mWiFiNetworkAgent);
- mCellNetworkAgent.addCapability(NET_CAPABILITY_TRUSTED);
- bestMatchingCb.expectAvailableDoubleValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent.removeCapability(NET_CAPABILITY_TRUSTED);
+ bestMatchingCb.expectAvailableCallbacksValidated(mWiFiAgent);
+ mCellAgent.addCapability(NET_CAPABILITY_TRUSTED);
+ bestMatchingCb.expectAvailableDoubleValidatedCallbacks(mCellAgent);
// Verify the callback doesn't care about wifi disconnect.
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
bestMatchingCb.assertNoCallback();
- mCellNetworkAgent.disconnect();
- bestMatchingCb.expect(LOST, mCellNetworkAgent);
+ mCellAgent.disconnect();
+ bestMatchingCb.expect(LOST, mCellAgent);
}
private UidRangeParcel[] uidRangeFor(final UserHandle handle) {
@@ -14795,18 +14741,17 @@
TestNetworkCallback disAllowProfileDefaultNetworkCallback) throws Exception {
final InOrder inOrder = inOrder(mMockNetd);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
- mSystemDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- profileDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mSystemDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ profileDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
if (disAllowProfileDefaultNetworkCallback != null) {
- disAllowProfileDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(
- mCellNetworkAgent);
+ disAllowProfileDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
}
inOrder.verify(mMockNetd).networkCreate(nativeNetworkConfigPhysical(
- mCellNetworkAgent.getNetwork().netId, INetd.PERMISSION_NONE));
+ mCellAgent.getNetwork().netId, INetd.PERMISSION_NONE));
final TestNetworkAgentWrapper workAgent =
makeEnterpriseNetworkAgent(profileNetworkPreference.getPreferenceEnterpriseId());
@@ -14833,7 +14778,7 @@
// system default is not handled specially, the rules are always active as long as
// a preference is set.
inOrder.verify(mMockNetd).networkAddUidRangesParcel(new NativeUidRangeConfig(
- mCellNetworkAgent.getNetwork().netId,
+ mCellAgent.getNetwork().netId,
uidRangeFor(testHandle, profileNetworkPreference),
PREFERENCE_ORDER_PROFILE));
}
@@ -14843,7 +14788,7 @@
if (allowFallback && !connectWorkProfileAgentAhead) {
assertNoCallbacks(profileDefaultNetworkCallback);
} else if (!connectWorkProfileAgentAhead) {
- profileDefaultNetworkCallback.expect(LOST, mCellNetworkAgent);
+ profileDefaultNetworkCallback.expect(LOST, mCellAgent);
if (disAllowProfileDefaultNetworkCallback != null) {
assertNoCallbacks(disAllowProfileDefaultNetworkCallback);
}
@@ -14868,7 +14813,7 @@
if (allowFallback && !connectWorkProfileAgentAhead) {
inOrder.verify(mMockNetd).networkRemoveUidRangesParcel(new NativeUidRangeConfig(
- mCellNetworkAgent.getNetwork().netId,
+ mCellAgent.getNetwork().netId,
uidRangeFor(testHandle, profileNetworkPreference),
PREFERENCE_ORDER_PROFILE));
}
@@ -14898,13 +14843,13 @@
// Conversely, change a capability on the system-wide default network and make sure
// that only the apps outside of the work profile receive the callbacks.
- mCellNetworkAgent.addCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED);
- mSystemDefaultNetworkCallback.expectCapabilitiesThat(mCellNetworkAgent, nc ->
+ mCellAgent.addCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED);
+ mSystemDefaultNetworkCallback.expectCapabilitiesThat(mCellAgent, nc ->
nc.hasCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED));
- mDefaultNetworkCallback.expectCapabilitiesThat(mCellNetworkAgent, nc ->
+ mDefaultNetworkCallback.expectCapabilitiesThat(mCellAgent, nc ->
nc.hasCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED));
if (disAllowProfileDefaultNetworkCallback != null) {
- disAllowProfileDefaultNetworkCallback.expectCapabilitiesThat(mCellNetworkAgent, nc ->
+ disAllowProfileDefaultNetworkCallback.expectCapabilitiesThat(mCellAgent, nc ->
nc.hasCapability(NET_CAPABILITY_TEMPORARILY_NOT_METERED));
}
profileDefaultNetworkCallback.assertNoCallback();
@@ -14912,34 +14857,33 @@
// Disconnect and reconnect the system-wide default network and make sure that the
// apps on this network see the appropriate callbacks, and the app on the work profile
// doesn't because it continues to use the enterprise network.
- mCellNetworkAgent.disconnect();
- mSystemDefaultNetworkCallback.expect(LOST, mCellNetworkAgent);
- mDefaultNetworkCallback.expect(LOST, mCellNetworkAgent);
+ mCellAgent.disconnect();
+ mSystemDefaultNetworkCallback.expect(LOST, mCellAgent);
+ mDefaultNetworkCallback.expect(LOST, mCellAgent);
if (disAllowProfileDefaultNetworkCallback != null) {
- disAllowProfileDefaultNetworkCallback.expect(LOST, mCellNetworkAgent);
+ disAllowProfileDefaultNetworkCallback.expect(LOST, mCellAgent);
}
profileDefaultNetworkCallback.assertNoCallback();
- inOrder.verify(mMockNetd).networkDestroy(mCellNetworkAgent.getNetwork().netId);
+ inOrder.verify(mMockNetd).networkDestroy(mCellAgent.getNetwork().netId);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- mSystemDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ mSystemDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
if (disAllowProfileDefaultNetworkCallback != null) {
- disAllowProfileDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(
- mCellNetworkAgent);
+ disAllowProfileDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
}
profileDefaultNetworkCallback.assertNoCallback();
inOrder.verify(mMockNetd).networkCreate(nativeNetworkConfigPhysical(
- mCellNetworkAgent.getNetwork().netId, INetd.PERMISSION_NONE));
+ mCellAgent.getNetwork().netId, INetd.PERMISSION_NONE));
// When the agent disconnects, test that the app on the work profile falls back to the
// default network.
workAgent.disconnect();
profileDefaultNetworkCallback.expect(LOST, workAgent);
if (allowFallback) {
- profileDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ profileDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellAgent);
if (disAllowProfileDefaultNetworkCallback != null) {
assertNoCallbacks(disAllowProfileDefaultNetworkCallback);
}
@@ -14947,26 +14891,26 @@
assertNoCallbacks(mSystemDefaultNetworkCallback, mDefaultNetworkCallback);
if (allowFallback) {
inOrder.verify(mMockNetd).networkAddUidRangesParcel(new NativeUidRangeConfig(
- mCellNetworkAgent.getNetwork().netId,
+ mCellAgent.getNetwork().netId,
uidRangeFor(testHandle, profileNetworkPreference),
PREFERENCE_ORDER_PROFILE));
}
inOrder.verify(mMockNetd).networkDestroy(workAgent.getNetwork().netId);
- mCellNetworkAgent.disconnect();
- mSystemDefaultNetworkCallback.expect(LOST, mCellNetworkAgent);
- mDefaultNetworkCallback.expect(LOST, mCellNetworkAgent);
+ mCellAgent.disconnect();
+ mSystemDefaultNetworkCallback.expect(LOST, mCellAgent);
+ mDefaultNetworkCallback.expect(LOST, mCellAgent);
if (disAllowProfileDefaultNetworkCallback != null) {
- disAllowProfileDefaultNetworkCallback.expect(LOST, mCellNetworkAgent);
+ disAllowProfileDefaultNetworkCallback.expect(LOST, mCellAgent);
}
if (allowFallback) {
- profileDefaultNetworkCallback.expect(LOST, mCellNetworkAgent);
+ profileDefaultNetworkCallback.expect(LOST, mCellAgent);
}
// Waiting for the handler to be idle before checking for networkDestroy is necessary
// here because ConnectivityService calls onLost before the network is fully torn down.
waitForIdle();
- inOrder.verify(mMockNetd).networkDestroy(mCellNetworkAgent.getNetwork().netId);
+ inOrder.verify(mMockNetd).networkDestroy(mCellAgent.getNetwork().netId);
// If the control comes here, callbacks seem to behave correctly in the presence of
// a default network when the enterprise network goes up and down. Now, make sure they
@@ -15349,23 +15293,23 @@
registerDefaultNetworkCallbackAsUid(appCb3, testWorkProfileAppUid3);
// Connect both a regular cell agent and an enterprise network first.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
final TestNetworkAgentWrapper workAgent1 = makeEnterpriseNetworkAgent(NET_ENTERPRISE_ID_1);
final TestNetworkAgentWrapper workAgent2 = makeEnterpriseNetworkAgent(NET_ENTERPRISE_ID_2);
workAgent1.connect(true);
workAgent2.connect(true);
- mSystemDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mSystemDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
- appCb1.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- appCb2.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- appCb3.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ appCb1.expectAvailableThenValidatedCallbacks(mCellAgent);
+ appCb2.expectAvailableThenValidatedCallbacks(mCellAgent);
+ appCb3.expectAvailableThenValidatedCallbacks(mCellAgent);
verify(mMockNetd).networkCreate(nativeNetworkConfigPhysical(
- mCellNetworkAgent.getNetwork().netId, INetd.PERMISSION_NONE));
+ mCellAgent.getNetwork().netId, INetd.PERMISSION_NONE));
verify(mMockNetd).networkCreate(nativeNetworkConfigPhysical(
workAgent1.getNetwork().netId, INetd.PERMISSION_SYSTEM));
verify(mMockNetd).networkCreate(nativeNetworkConfigPhysical(
@@ -15432,8 +15376,8 @@
assertNoCallbacks(mSystemDefaultNetworkCallback, mDefaultNetworkCallback);
appCb3.expectAvailableCallbacksValidated(workAgent1);
- appCb2.expectAvailableCallbacksValidated(mCellNetworkAgent);
- appCb1.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ appCb2.expectAvailableCallbacksValidated(mCellAgent);
+ appCb1.expectAvailableCallbacksValidated(mCellAgent);
// Set the preferences for testHandle to default.
ProfileNetworkPreference.Builder profileNetworkPreferenceBuilder =
@@ -15450,9 +15394,9 @@
PREFERENCE_ORDER_PROFILE));
assertNoCallbacks(mSystemDefaultNetworkCallback, mDefaultNetworkCallback, appCb1, appCb2);
- appCb3.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ appCb3.expectAvailableCallbacksValidated(mCellAgent);
workAgent2.disconnect();
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
mCm.unregisterNetworkCallback(appCb1);
mCm.unregisterNetworkCallback(appCb2);
@@ -15497,8 +15441,8 @@
registerDefaultNetworkCallbackAsUid(appCb5, testWorkProfileAppUid5);
// Connect both a regular cell agent and an enterprise network first.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
final TestNetworkAgentWrapper workAgent1 = makeEnterpriseNetworkAgent(NET_ENTERPRISE_ID_1);
final TestNetworkAgentWrapper workAgent2 = makeEnterpriseNetworkAgent(NET_ENTERPRISE_ID_2);
@@ -15512,16 +15456,16 @@
workAgent4.connect(true);
workAgent5.connect(true);
- mSystemDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- appCb1.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- appCb2.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- appCb3.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- appCb4.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- appCb5.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mSystemDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ appCb1.expectAvailableThenValidatedCallbacks(mCellAgent);
+ appCb2.expectAvailableThenValidatedCallbacks(mCellAgent);
+ appCb3.expectAvailableThenValidatedCallbacks(mCellAgent);
+ appCb4.expectAvailableThenValidatedCallbacks(mCellAgent);
+ appCb5.expectAvailableThenValidatedCallbacks(mCellAgent);
verify(mMockNetd).networkCreate(nativeNetworkConfigPhysical(
- mCellNetworkAgent.getNetwork().netId, INetd.PERMISSION_NONE));
+ mCellAgent.getNetwork().netId, INetd.PERMISSION_NONE));
verify(mMockNetd).networkCreate(nativeNetworkConfigPhysical(
workAgent1.getNetwork().netId, INetd.PERMISSION_SYSTEM));
verify(mMockNetd).networkCreate(nativeNetworkConfigPhysical(
@@ -15619,30 +15563,30 @@
appCb4.expect(LOST, workAgent4);
appCb5.expect(LOST, workAgent5);
- appCb1.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ appCb1.expectAvailableCallbacksValidated(mCellAgent);
appCb2.assertNoCallback();
- appCb3.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ appCb3.expectAvailableCallbacksValidated(mCellAgent);
appCb4.assertNoCallback();
- appCb5.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ appCb5.expectAvailableCallbacksValidated(mCellAgent);
verify(mMockNetd).networkAddUidRangesParcel(new NativeUidRangeConfig(
- mCellNetworkAgent.getNetwork().netId,
+ mCellAgent.getNetwork().netId,
uidRangeFor(testHandle, profileNetworkPreferenceBuilder1.build()),
PREFERENCE_ORDER_PROFILE));
verify(mMockNetd, never()).networkAddUidRangesParcel(new NativeUidRangeConfig(
- mCellNetworkAgent.getNetwork().netId,
+ mCellAgent.getNetwork().netId,
uidRangeFor(testHandle, profileNetworkPreferenceBuilder2.build()),
PREFERENCE_ORDER_PROFILE));
verify(mMockNetd).networkAddUidRangesParcel(new NativeUidRangeConfig(
- mCellNetworkAgent.getNetwork().netId,
+ mCellAgent.getNetwork().netId,
uidRangeFor(testHandle, profileNetworkPreferenceBuilder3.build()),
PREFERENCE_ORDER_PROFILE));
verify(mMockNetd, never()).networkAddUidRangesParcel(new NativeUidRangeConfig(
- mCellNetworkAgent.getNetwork().netId,
+ mCellAgent.getNetwork().netId,
uidRangeFor(testHandle, profileNetworkPreferenceBuilder4.build()),
PREFERENCE_ORDER_PROFILE));
verify(mMockNetd).networkAddUidRangesParcel(new NativeUidRangeConfig(
- mCellNetworkAgent.getNetwork().netId,
+ mCellAgent.getNetwork().netId,
uidRangeFor(testHandle, profileNetworkPreferenceBuilder5.build()),
PREFERENCE_ORDER_PROFILE));
@@ -15660,9 +15604,9 @@
listener.expectOnComplete();
assertNoCallbacks(mSystemDefaultNetworkCallback, mDefaultNetworkCallback, appCb1, appCb3,
appCb5);
- appCb2.expectAvailableCallbacksValidated(mCellNetworkAgent);
- appCb4.expectAvailableCallbacksValidated(mCellNetworkAgent);
- mCellNetworkAgent.disconnect();
+ appCb2.expectAvailableCallbacksValidated(mCellAgent);
+ appCb4.expectAvailableCallbacksValidated(mCellAgent);
+ mCellAgent.disconnect();
mCm.unregisterNetworkCallback(appCb1);
mCm.unregisterNetworkCallback(appCb2);
@@ -15682,8 +15626,8 @@
final UserHandle testHandle = setupEnterpriseNetwork();
// Connect both a regular cell agent and an enterprise network first.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
final TestNetworkAgentWrapper workAgent = makeEnterpriseNetworkAgent();
workAgent.connect(true);
@@ -15693,27 +15637,27 @@
r -> r.run(), listener);
listener.expectOnComplete();
inOrder.verify(mMockNetd).networkCreate(nativeNetworkConfigPhysical(
- mCellNetworkAgent.getNetwork().netId, INetd.PERMISSION_NONE));
+ mCellAgent.getNetwork().netId, INetd.PERMISSION_NONE));
inOrder.verify(mMockNetd).networkAddUidRangesParcel(new NativeUidRangeConfig(
workAgent.getNetwork().netId, uidRangeFor(testHandle), PREFERENCE_ORDER_PROFILE));
registerDefaultNetworkCallbacks();
- mSystemDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
- mDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ mSystemDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellAgent);
+ mDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellAgent);
mProfileDefaultNetworkCallback.expectAvailableCallbacksValidated(workAgent);
mCm.setProfileNetworkPreference(testHandle, PROFILE_NETWORK_PREFERENCE_DEFAULT,
r -> r.run(), listener);
listener.expectOnComplete();
- mProfileDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ mProfileDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellAgent);
assertNoCallbacks(mSystemDefaultNetworkCallback, mDefaultNetworkCallback);
inOrder.verify(mMockNetd).networkRemoveUidRangesParcel(new NativeUidRangeConfig(
workAgent.getNetwork().netId, uidRangeFor(testHandle), PREFERENCE_ORDER_PROFILE));
workAgent.disconnect();
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
// Callbacks will be unregistered by tearDown()
}
@@ -15735,18 +15679,18 @@
registerDefaultNetworkCallbackAsUid(app4Cb, testWorkProfileAppUid4);
// Connect both a regular cell agent and an enterprise network first.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
final TestNetworkAgentWrapper workAgent = makeEnterpriseNetworkAgent();
workAgent.connect(true);
- mSystemDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- mProfileDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- app4Cb.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mSystemDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ mProfileDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ app4Cb.expectAvailableThenValidatedCallbacks(mCellAgent);
inOrder.verify(mMockNetd).networkCreate(nativeNetworkConfigPhysical(
- mCellNetworkAgent.getNetwork().netId, INetd.PERMISSION_NONE));
+ mCellAgent.getNetwork().netId, INetd.PERMISSION_NONE));
inOrder.verify(mMockNetd).networkCreate(nativeNetworkConfigPhysical(
workAgent.getNetwork().netId, INetd.PERMISSION_SYSTEM));
@@ -15777,12 +15721,12 @@
inOrder.verify(mMockNetd).networkRemoveUidRangesParcel(new NativeUidRangeConfig(
workAgent.getNetwork().netId, uidRangeFor(testHandle2), PREFERENCE_ORDER_PROFILE));
- mProfileDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ mProfileDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellAgent);
assertNoCallbacks(mSystemDefaultNetworkCallback, mDefaultNetworkCallback,
app4Cb);
workAgent.disconnect();
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
mCm.unregisterNetworkCallback(app4Cb);
// Other callbacks will be unregistered by tearDown()
@@ -15793,17 +15737,17 @@
final InOrder inOrder = inOrder(mMockNetd);
final UserHandle testHandle = setupEnterpriseNetwork();
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
final TestOnCompleteListener listener = new TestOnCompleteListener();
mCm.setProfileNetworkPreference(testHandle, PROFILE_NETWORK_PREFERENCE_ENTERPRISE,
r -> r.run(), listener);
listener.expectOnComplete();
inOrder.verify(mMockNetd).networkCreate(nativeNetworkConfigPhysical(
- mCellNetworkAgent.getNetwork().netId, INetd.PERMISSION_NONE));
+ mCellAgent.getNetwork().netId, INetd.PERMISSION_NONE));
inOrder.verify(mMockNetd).networkAddUidRangesParcel(new NativeUidRangeConfig(
- mCellNetworkAgent.getNetwork().netId, uidRangeFor(testHandle),
+ mCellAgent.getNetwork().netId, uidRangeFor(testHandle),
PREFERENCE_ORDER_PROFILE));
final Intent removedIntent = new Intent(ACTION_USER_REMOVED);
@@ -15811,7 +15755,7 @@
processBroadcast(removedIntent);
inOrder.verify(mMockNetd).networkRemoveUidRangesParcel(new NativeUidRangeConfig(
- mCellNetworkAgent.getNetwork().netId, uidRangeFor(testHandle),
+ mCellAgent.getNetwork().netId, uidRangeFor(testHandle),
PREFERENCE_ORDER_PROFILE));
}
@@ -15824,8 +15768,8 @@
// Start with 1 default network and 1 enterprise network, both networks should
// not be restricted since the blocking preference is not set yet.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
// Verify uid ranges 0~99999, 200000~299999 are all allowed for cellular.
final UidRange profileUidRange =
@@ -15836,7 +15780,7 @@
final UidRangeParcel[] allowAllUidRangesParcel = toUidRangeStableParcels(
allowedAllUidRanges);
final NativeUidRangeConfig cellAllAllowedConfig = new NativeUidRangeConfig(
- mCellNetworkAgent.getNetwork().netId,
+ mCellAgent.getNetwork().netId,
allowAllUidRangesParcel,
0 /* subPriority */);
inOrder.verify(mMockNetd).setNetworkAllowlist(
@@ -15881,7 +15825,7 @@
));
final UidRangeParcel[] excludeAppRangesParcel = toUidRangeStableParcels(excludeAppRanges);
final NativeUidRangeConfig cellExcludeAppConfig = new NativeUidRangeConfig(
- mCellNetworkAgent.getNetwork().netId,
+ mCellAgent.getNetwork().netId,
excludeAppRangesParcel,
0 /* subPriority */);
inOrder.verify(mMockNetd).setNetworkAllowlist(configsCaptor.capture());
@@ -15925,8 +15869,8 @@
// Start with 1 default network, which should be restricted since the blocking
// preference is already set.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
// Verify cellular network applies to the allow list.
// Cell: 0~99999, 200000~TEST_APP_UID-1, TEST_APP_UID+1~299999
@@ -15942,7 +15886,7 @@
));
final UidRangeParcel[] excludeAppRangesParcel = toUidRangeStableParcels(excludeAppRanges);
final NativeUidRangeConfig cellExcludeAppConfig = new NativeUidRangeConfig(
- mCellNetworkAgent.getNetwork().netId,
+ mCellAgent.getNetwork().netId,
excludeAppRangesParcel,
0 /* subPriority */);
inOrder.verify(mMockNetd).setNetworkAllowlist(
@@ -15975,7 +15919,7 @@
inOrder.verify(mMockNetd).setNetworkAllowlist(
new NativeUidRangeConfig[]{cellExcludeAppConfig});
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
waitForIdle();
inOrder.verify(mMockNetd).setNetworkAllowlist(new NativeUidRangeConfig[]{});
}
@@ -16225,7 +16169,7 @@
.addCapability(NET_CAPABILITY_NOT_VCN_MANAGED)
.removeCapability(NET_CAPABILITY_NOT_RESTRICTED);
- mEthernetNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_ETHERNET,
+ mEthernetAgent = new TestNetworkAgentWrapper(TRANSPORT_ETHERNET,
new LinkProperties(), ncb.build());
final ArraySet<Integer> serviceUidSet = new ArraySet<>();
@@ -16237,22 +16181,22 @@
.addTransportType(TRANSPORT_ETHERNET)
.removeCapability(NET_CAPABILITY_NOT_RESTRICTED)
.build(), cb);
- mEthernetNetworkAgent.connect(true);
- cb.expectAvailableThenValidatedCallbacks(mEthernetNetworkAgent);
+ mEthernetAgent.connect(true);
+ cb.expectAvailableThenValidatedCallbacks(mEthernetAgent);
// Cell gets to set the service UID as access UID
ncb.setAllowedUids(serviceUidSet);
- mEthernetNetworkAgent.setNetworkCapabilities(ncb.build(), true /* sendToCS */);
+ mEthernetAgent.setNetworkCapabilities(ncb.build(), true /* sendToCS */);
if (SdkLevel.isAtLeastT() && hasAutomotiveFeature) {
- cb.expectCapabilitiesThat(mEthernetNetworkAgent,
+ cb.expectCapabilitiesThat(mEthernetAgent,
caps -> caps.getAllowedUids().equals(serviceUidSet));
} else {
// S and no automotive feature must ignore access UIDs.
cb.assertNoCallback(TEST_CALLBACK_TIMEOUT_MS);
}
- mEthernetNetworkAgent.disconnect();
- cb.expect(LOST, mEthernetNetworkAgent);
+ mEthernetAgent.disconnect();
+ cb.expect(LOST, mEthernetAgent);
mCm.unregisterNetworkCallback(cb);
}
@@ -16275,7 +16219,7 @@
.removeCapability(NET_CAPABILITY_NOT_RESTRICTED)
.setNetworkSpecifier(new TelephonyNetworkSpecifier(1 /* subid */));
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR,
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR,
new LinkProperties(), ncb.build());
final ArraySet<Integer> serviceUidSet = new ArraySet<>();
@@ -16293,13 +16237,12 @@
.addTransportType(TRANSPORT_CELLULAR)
.removeCapability(NET_CAPABILITY_NOT_RESTRICTED)
.build(), cb);
- mCellNetworkAgent.connect(true);
- cb.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent.connect(true);
+ cb.expectAvailableThenValidatedCallbacks(mCellAgent);
ncb.setAllowedUids(serviceUidSet);
- mCellNetworkAgent.setNetworkCapabilities(ncb.build(), true /* sendToCS */);
+ mCellAgent.setNetworkCapabilities(ncb.build(), true /* sendToCS */);
if (SdkLevel.isAtLeastT()) {
- cb.expectCapabilitiesThat(mCellNetworkAgent,
- caps -> caps.getAllowedUids().equals(serviceUidSet));
+ cb.expectCapabilitiesThat(mCellAgent, cp -> cp.getAllowedUids().equals(serviceUidSet));
} else {
// S must ignore access UIDs.
cb.assertNoCallback(TEST_CALLBACK_TIMEOUT_MS);
@@ -16307,10 +16250,9 @@
// ...but not to some other UID. Rejection sets UIDs to the empty set
ncb.setAllowedUids(nonServiceUidSet);
- mCellNetworkAgent.setNetworkCapabilities(ncb.build(), true /* sendToCS */);
+ mCellAgent.setNetworkCapabilities(ncb.build(), true /* sendToCS */);
if (SdkLevel.isAtLeastT()) {
- cb.expectCapabilitiesThat(mCellNetworkAgent,
- caps -> caps.getAllowedUids().isEmpty());
+ cb.expectCapabilitiesThat(mCellAgent, cp -> cp.getAllowedUids().isEmpty());
} else {
// S must ignore access UIDs.
cb.assertNoCallback(TEST_CALLBACK_TIMEOUT_MS);
@@ -16318,11 +16260,11 @@
// ...and also not to multiple UIDs even including the service UID
ncb.setAllowedUids(serviceUidSetPlus);
- mCellNetworkAgent.setNetworkCapabilities(ncb.build(), true /* sendToCS */);
+ mCellAgent.setNetworkCapabilities(ncb.build(), true /* sendToCS */);
cb.assertNoCallback(TEST_CALLBACK_TIMEOUT_MS);
- mCellNetworkAgent.disconnect();
- cb.expect(LOST, mCellNetworkAgent);
+ mCellAgent.disconnect();
+ cb.expect(LOST, mCellAgent);
mCm.unregisterNetworkCallback(cb);
// Must be unset before touching the transports, because remove and add transport types
@@ -16336,12 +16278,11 @@
.addTransportType(TRANSPORT_WIFI)
.removeCapability(NET_CAPABILITY_NOT_RESTRICTED)
.build(), cb);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI,
- new LinkProperties(), ncb.build());
- mWiFiNetworkAgent.connect(true);
- cb.expectAvailableThenValidatedCallbacks(mWiFiNetworkAgent);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, new LinkProperties(), ncb.build());
+ mWiFiAgent.connect(true);
+ cb.expectAvailableThenValidatedCallbacks(mWiFiAgent);
ncb.setAllowedUids(serviceUidSet);
- mWiFiNetworkAgent.setNetworkCapabilities(ncb.build(), true /* sendToCS */);
+ mWiFiAgent.setNetworkCapabilities(ncb.build(), true /* sendToCS */);
cb.assertNoCallback(TEST_CALLBACK_TIMEOUT_MS);
mCm.unregisterNetworkCallback(cb);
}
@@ -16528,12 +16469,12 @@
public void testMobileDataPreferredUidsChanged() throws Exception {
final InOrder inorder = inOrder(mMockNetd);
registerDefaultNetworkCallbacks();
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- mTestPackageDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ mTestPackageDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
- final int cellNetId = mCellNetworkAgent.getNetwork().netId;
+ final int cellNetId = mCellAgent.getNetwork().netId;
inorder.verify(mMockNetd, times(1)).networkCreate(nativeNetworkConfigPhysical(
cellNetId, INetd.PERMISSION_NONE));
@@ -16586,13 +16527,13 @@
cellNetworkCallback.assertNoCallback();
registerDefaultNetworkCallbacks();
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
- mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mWiFiNetworkAgent);
- mTestPackageDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mWiFiNetworkAgent);
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
+ mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mWiFiAgent);
+ mTestPackageDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mWiFiAgent);
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
- final int wifiNetId = mWiFiNetworkAgent.getNetwork().netId;
+ final int wifiNetId = mWiFiAgent.getNetwork().netId;
inorder.verify(mMockNetd, times(1)).networkCreate(nativeNetworkConfigPhysical(
wifiNetId, INetd.PERMISSION_NONE));
@@ -16613,14 +16554,14 @@
// Cellular network connected. mTestPackageDefaultNetworkCallback should receive
// callback with cellular network and net id and uid ranges should be updated to netd.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
mDefaultNetworkCallback.assertNoCallback();
- mTestPackageDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
+ mTestPackageDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
- final int cellNetId = mCellNetworkAgent.getNetwork().netId;
+ final int cellNetId = mCellAgent.getNetwork().netId;
final NativeUidRangeConfig cellConfig = new NativeUidRangeConfig(cellNetId, uidRanges,
PREFERENCE_ORDER_MOBILE_DATA_PREFERERRED);
inorder.verify(mMockNetd, times(1)).networkCreate(nativeNetworkConfigPhysical(
@@ -16630,26 +16571,26 @@
// Cellular network disconnected. mTestPackageDefaultNetworkCallback should receive
// callback with wifi network from fallback request.
- mCellNetworkAgent.disconnect();
+ mCellAgent.disconnect();
mDefaultNetworkCallback.assertNoCallback();
- cellNetworkCallback.expect(LOST, mCellNetworkAgent);
- mTestPackageDefaultNetworkCallback.expect(LOST, mCellNetworkAgent);
- mTestPackageDefaultNetworkCallback.expectAvailableCallbacksValidated(mWiFiNetworkAgent);
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
+ cellNetworkCallback.expect(LOST, mCellAgent);
+ mTestPackageDefaultNetworkCallback.expect(LOST, mCellAgent);
+ mTestPackageDefaultNetworkCallback.expectAvailableCallbacksValidated(mWiFiAgent);
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
inorder.verify(mMockNetd, times(1)).networkAddUidRangesParcel(wifiConfig);
inorder.verify(mMockNetd, never()).networkRemoveUidRangesParcel(any());
inorder.verify(mMockNetd).networkDestroy(cellNetId);
// Cellular network comes back. mTestPackageDefaultNetworkCallback should receive
// callback with cellular network.
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
mDefaultNetworkCallback.assertNoCallback();
- mTestPackageDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
+ mTestPackageDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
- final int cellNetId2 = mCellNetworkAgent.getNetwork().netId;
+ final int cellNetId2 = mCellAgent.getNetwork().netId;
final NativeUidRangeConfig cellConfig2 = new NativeUidRangeConfig(cellNetId2, uidRanges,
PREFERENCE_ORDER_MOBILE_DATA_PREFERERRED);
inorder.verify(mMockNetd, times(1)).networkCreate(nativeNetworkConfigPhysical(
@@ -16659,11 +16600,11 @@
// Wifi network disconnected. mTestPackageDefaultNetworkCallback should not receive
// any callback.
- mWiFiNetworkAgent.disconnect();
- mDefaultNetworkCallback.expect(LOST, mWiFiNetworkAgent);
- mDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ mWiFiAgent.disconnect();
+ mDefaultNetworkCallback.expect(LOST, mWiFiAgent);
+ mDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellAgent);
mTestPackageDefaultNetworkCallback.assertNoCallback();
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
waitForIdle();
inorder.verify(mMockNetd, never()).networkAddUidRangesParcel(any());
inorder.verify(mMockNetd, never()).networkRemoveUidRangesParcel(any());
@@ -16695,15 +16636,15 @@
cellFactory.expectRequestAdds(2);
cellFactory.assertRequestCountEquals(2);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
// The cellFactory however is outscored, and should lose default internet request.
// But it should still see mobile data preferred request.
cellFactory.expectRequestRemove();
cellFactory.assertRequestCountEquals(1);
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
// The network satisfying the default internet request has disconnected, so the
// cellFactory sees the default internet requests again.
cellFactory.expectRequestAdd();
@@ -16745,7 +16686,7 @@
final UserHandle testHandle = setupEnterpriseNetwork();
setOemNetworkPreferenceAgentConnected(TRANSPORT_CELLULAR, true);
- final int cellNetId = mCellNetworkAgent.getNetwork().netId;
+ final int cellNetId = mCellAgent.getNetwork().netId;
inorder.verify(mMockNetd, times(1)).networkCreate(nativeNetworkConfigPhysical(
cellNetId, INetd.PERMISSION_NONE));
@@ -16818,28 +16759,28 @@
// Register callbacks and have wifi network as default network.
registerDefaultNetworkCallbacks();
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.connect(true);
- mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mWiFiNetworkAgent);
- mProfileDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mWiFiNetworkAgent);
- mTestPackageDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mWiFiNetworkAgent);
- assertEquals(mWiFiNetworkAgent.getNetwork(),
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
+ mDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mWiFiAgent);
+ mProfileDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mWiFiAgent);
+ mTestPackageDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mWiFiAgent);
+ assertEquals(mWiFiAgent.getNetwork(),
mCm.getActiveNetworkForUid(TEST_WORK_PROFILE_APP_UID));
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
// Set MOBILE_DATA_PREFERRED_UIDS setting with TEST_WORK_PROFILE_APP_UID and
// TEST_PACKAGE_UID. Both mProfileDefaultNetworkCallback and
// mTestPackageDefaultNetworkCallback should receive callback with cell network.
setAndUpdateMobileDataPreferredUids(Set.of(TEST_WORK_PROFILE_APP_UID, TEST_PACKAGE_UID));
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
- cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ cellNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
mDefaultNetworkCallback.assertNoCallback();
- mProfileDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- mTestPackageDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);
- assertEquals(mCellNetworkAgent.getNetwork(),
+ mProfileDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ mTestPackageDefaultNetworkCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+ assertEquals(mCellAgent.getNetwork(),
mCm.getActiveNetworkForUid(TEST_WORK_PROFILE_APP_UID));
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
// Set user profile network preference with test profile. mProfileDefaultNetworkCallback
// should receive callback with higher priority network preference (enterprise network).
@@ -16854,7 +16795,7 @@
assertNoCallbacks(mDefaultNetworkCallback, mTestPackageDefaultNetworkCallback);
mProfileDefaultNetworkCallback.expectAvailableCallbacksValidated(workAgent);
assertEquals(workAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_WORK_PROFILE_APP_UID));
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
// Set oem network preference with TEST_PACKAGE_UID. mTestPackageDefaultNetworkCallback
// should receive callback with higher priority network preference (current default network)
@@ -16865,8 +16806,8 @@
final UidRangeParcel[] uidRanges1 = toUidRangeStableParcels(uidRangesForUids(uids1));
setupSetOemNetworkPreferenceForPreferenceTest(networkPref, uidRanges1, TEST_PACKAGE_NAME);
assertNoCallbacks(mDefaultNetworkCallback, mProfileDefaultNetworkCallback);
- mTestPackageDefaultNetworkCallback.expectAvailableCallbacksValidated(mWiFiNetworkAgent);
- assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
+ mTestPackageDefaultNetworkCallback.expectAvailableCallbacksValidated(mWiFiAgent);
+ assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
assertEquals(workAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_WORK_PROFILE_APP_UID));
// Set oem network preference with TEST_WORK_PROFILE_APP_UID. Both
@@ -16878,11 +16819,11 @@
setupSetOemNetworkPreferenceForPreferenceTest(
networkPref, uidRanges2, "com.android.test", testHandle);
mDefaultNetworkCallback.assertNoCallback();
- mProfileDefaultNetworkCallback.expectAvailableCallbacksValidated(mWiFiNetworkAgent);
- mTestPackageDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
- assertEquals(mWiFiNetworkAgent.getNetwork(),
+ mProfileDefaultNetworkCallback.expectAvailableCallbacksValidated(mWiFiAgent);
+ mTestPackageDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellAgent);
+ assertEquals(mWiFiAgent.getNetwork(),
mCm.getActiveNetworkForUid(TEST_WORK_PROFILE_APP_UID));
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
// Remove oem network preference, mProfileDefaultNetworkCallback should receive callback
// with current highest priority network preference (enterprise network) and the others
@@ -16894,23 +16835,23 @@
assertNoCallbacks(mDefaultNetworkCallback, mTestPackageDefaultNetworkCallback);
mProfileDefaultNetworkCallback.expectAvailableCallbacksValidated(workAgent);
assertEquals(workAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_WORK_PROFILE_APP_UID));
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
// Remove user profile network preference.
mCm.setProfileNetworkPreference(testHandle, PROFILE_NETWORK_PREFERENCE_DEFAULT,
r -> r.run(), listener);
listener.expectOnComplete();
assertNoCallbacks(mDefaultNetworkCallback, mTestPackageDefaultNetworkCallback);
- mProfileDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
- assertEquals(mCellNetworkAgent.getNetwork(),
+ mProfileDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellAgent);
+ assertEquals(mCellAgent.getNetwork(),
mCm.getActiveNetworkForUid(TEST_WORK_PROFILE_APP_UID));
- assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
+ assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetworkForUid(TEST_PACKAGE_UID));
// Disconnect wifi
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
assertNoCallbacks(mProfileDefaultNetworkCallback, mTestPackageDefaultNetworkCallback);
- mDefaultNetworkCallback.expect(LOST, mWiFiNetworkAgent);
- mDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ mDefaultNetworkCallback.expect(LOST, mWiFiAgent);
+ mDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellAgent);
}
@Test
@@ -16924,13 +16865,13 @@
public void testUpdateRateLimit_EnableDisable() throws Exception {
final LinkProperties wifiLp = new LinkProperties();
wifiLp.setInterfaceName(WIFI_IFNAME);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
+ mWiFiAgent.connect(true);
final LinkProperties cellLp = new LinkProperties();
cellLp.setInterfaceName(MOBILE_IFNAME);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
- mCellNetworkAgent.connect(false);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
+ mCellAgent.connect(false);
waitForIdle();
@@ -16963,8 +16904,8 @@
public void testUpdateRateLimit_WhenNewNetworkIsAdded() throws Exception {
final LinkProperties wifiLp = new LinkProperties();
wifiLp.setInterfaceName(WIFI_IFNAME);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
+ mWiFiAgent.connect(true);
waitForIdle();
@@ -16979,8 +16920,8 @@
final LinkProperties cellLp = new LinkProperties();
cellLp.setInterfaceName(MOBILE_IFNAME);
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
- mCellNetworkAgent.connect(false);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);
+ mCellAgent.connect(false);
assertNotNull(readHead.poll(TIMEOUT_MS, it -> it.first == cellLp.getInterfaceName()
&& it.second == rateLimitInBytesPerSec));
}
@@ -16990,8 +16931,8 @@
final LinkProperties wifiLp = new LinkProperties();
wifiLp.setInterfaceName(WIFI_IFNAME);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
- mWiFiNetworkAgent.connectWithoutInternet();
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
+ mWiFiAgent.connectWithoutInternet();
waitForIdle();
@@ -17015,8 +16956,8 @@
// - ensure network interface is not rate limited
final LinkProperties wifiLp = new LinkProperties();
wifiLp.setInterfaceName(WIFI_IFNAME);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
+ mWiFiAgent.connect(true);
waitForIdle();
final ArrayTrackRecord<Pair<String, Long>>.ReadHead readHeadWifi =
@@ -17028,14 +16969,14 @@
it -> it.first == wifiLp.getInterfaceName()
&& it.second == rateLimitInBytesPerSec));
- mWiFiNetworkAgent.disconnect();
+ mWiFiAgent.disconnect();
assertNotNull(readHeadWifi.poll(TIMEOUT_MS,
it -> it.first == wifiLp.getInterfaceName() && it.second == -1));
setIngressRateLimit(-1);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
+ mWiFiAgent.connect(true);
assertNull(readHeadWifi.poll(TIMEOUT_MS, it -> it.first == wifiLp.getInterfaceName()));
}
@@ -17043,8 +16984,8 @@
public void testUpdateRateLimit_UpdateExistingRateLimit() throws Exception {
final LinkProperties wifiLp = new LinkProperties();
wifiLp.setInterfaceName(WIFI_IFNAME);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
+ mWiFiAgent.connect(true);
waitForIdle();
final ArrayTrackRecord<Pair<String, Long>>.ReadHead readHeadWifi =
@@ -17073,8 +17014,8 @@
public void testUpdateRateLimit_DoesNothingBeforeT() throws Exception {
final LinkProperties wifiLp = new LinkProperties();
wifiLp.setInterfaceName(WIFI_IFNAME);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);
+ mWiFiAgent.connect(true);
waitForIdle();
final ArrayTrackRecord<Pair<String, Long>>.ReadHead readHead =
@@ -17113,8 +17054,8 @@
final String bssid1 = "AA:AA:AA:AA:AA:AA";
final String bssid2 = "BB:BB:BB:BB:BB:BB";
- mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
- mCellNetworkAgent.connect(true);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
NetworkCapabilities wifiNc1 = new NetworkCapabilities()
.addCapability(NET_CAPABILITY_INTERNET)
.addCapability(NET_CAPABILITY_NOT_VPN)
@@ -17127,101 +17068,98 @@
.setTransportInfo(new WifiInfo.Builder().setBssid(bssid2).build());
final LinkProperties wifiLp = new LinkProperties();
wifiLp.setInterfaceName(WIFI_IFNAME);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp, wifiNc1);
- mWiFiNetworkAgent.connect(true);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp, wifiNc1);
+ mWiFiAgent.connect(true);
// The default network will be switching to Wi-Fi Network.
final TestNetworkCallback wifiNetworkCallback = new TestNetworkCallback();
final NetworkRequest wifiRequest = new NetworkRequest.Builder()
.addTransportType(TRANSPORT_WIFI).build();
mCm.requestNetwork(wifiRequest, wifiNetworkCallback);
- wifiNetworkCallback.expectAvailableCallbacksValidated(mWiFiNetworkAgent);
+ wifiNetworkCallback.expectAvailableCallbacksValidated(mWiFiAgent);
registerDefaultNetworkCallbacks();
- mDefaultNetworkCallback.expectAvailableCallbacksValidated(mWiFiNetworkAgent);
+ mDefaultNetworkCallback.expectAvailableCallbacksValidated(mWiFiAgent);
// There is a bug in the current code where ignoring validation after roam will not
// correctly change the default network if the result if the validation is partial or
// captive portal. TODO : fix the bug and reinstate this code.
if (false) {
// Wi-Fi roaming from wifiNc1 to wifiNc2 but the network is now behind a captive portal.
- mWiFiNetworkAgent.setNetworkCapabilities(wifiNc2, true /* sendToConnectivityService */);
+ mWiFiAgent.setNetworkCapabilities(wifiNc2, true /* sendToConnectivityService */);
// The only thing changed in this CAPS is the BSSID, which can't be tested for in this
// test because it's redacted.
- wifiNetworkCallback.expect(NETWORK_CAPS_UPDATED, mWiFiNetworkAgent);
- mDefaultNetworkCallback.expect(NETWORK_CAPS_UPDATED, mWiFiNetworkAgent);
- mWiFiNetworkAgent.setNetworkPortal(TEST_REDIRECT_URL,
- false /* privateDnsProbeSent */);
- mCm.reportNetworkConnectivity(mWiFiNetworkAgent.getNetwork(), false);
+ wifiNetworkCallback.expect(NETWORK_CAPS_UPDATED, mWiFiAgent);
+ mDefaultNetworkCallback.expect(NETWORK_CAPS_UPDATED, mWiFiAgent);
+ mWiFiAgent.setNetworkPortal(TEST_REDIRECT_URL, false /* privateDnsProbeSent */);
+ mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), false);
// Wi-Fi is now detected to have a portal : cell should become the default network.
- mDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
- wifiNetworkCallback.expectCapabilitiesWithout(NET_CAPABILITY_VALIDATED,
- mWiFiNetworkAgent);
- wifiNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_CAPTIVE_PORTAL,
- mWiFiNetworkAgent);
+ mDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellAgent);
+ wifiNetworkCallback.expectCapabilitiesWithout(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ wifiNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_CAPTIVE_PORTAL, mWiFiAgent);
// Wi-Fi becomes valid again. The default network goes back to Wi-Fi.
- mWiFiNetworkAgent.setNetworkValid(false /* privateDnsProbeSent */);
- mCm.reportNetworkConnectivity(mWiFiNetworkAgent.getNetwork(), true);
- mDefaultNetworkCallback.expectAvailableCallbacksValidated(mWiFiNetworkAgent);
+ mWiFiAgent.setNetworkValid(false /* privateDnsProbeSent */);
+ mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), true);
+ mDefaultNetworkCallback.expectAvailableCallbacksValidated(mWiFiAgent);
wifiNetworkCallback.expectCapabilitiesWithout(NET_CAPABILITY_CAPTIVE_PORTAL,
- mWiFiNetworkAgent);
+ mWiFiAgent);
// Wi-Fi roaming from wifiNc2 to wifiNc1, and the network now has partial connectivity.
- mWiFiNetworkAgent.setNetworkCapabilities(wifiNc1, true);
- wifiNetworkCallback.expect(NETWORK_CAPS_UPDATED, mWiFiNetworkAgent);
- mDefaultNetworkCallback.expect(NETWORK_CAPS_UPDATED, mWiFiNetworkAgent);
- mWiFiNetworkAgent.setNetworkPartial();
- mCm.reportNetworkConnectivity(mWiFiNetworkAgent.getNetwork(), false);
+ mWiFiAgent.setNetworkCapabilities(wifiNc1, true);
+ wifiNetworkCallback.expect(NETWORK_CAPS_UPDATED, mWiFiAgent);
+ mDefaultNetworkCallback.expect(NETWORK_CAPS_UPDATED, mWiFiAgent);
+ mWiFiAgent.setNetworkPartial();
+ mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), false);
// Wi-Fi now only offers partial connectivity, so in the absence of accepting partial
// connectivity explicitly for this network, it loses default status to cell.
- mDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ mDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellAgent);
wifiNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_PARTIAL_CONNECTIVITY,
- mWiFiNetworkAgent);
+ mWiFiAgent);
// Wi-Fi becomes valid again. The default network goes back to Wi-Fi.
- mWiFiNetworkAgent.setNetworkValid(false /* privateDnsProbeSent */);
- mCm.reportNetworkConnectivity(mWiFiNetworkAgent.getNetwork(), true);
- mDefaultNetworkCallback.expectAvailableCallbacksValidated(mWiFiNetworkAgent);
+ mWiFiAgent.setNetworkValid(false /* privateDnsProbeSent */);
+ mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), true);
+ mDefaultNetworkCallback.expectAvailableCallbacksValidated(mWiFiAgent);
wifiNetworkCallback.expectCapabilitiesWithout(NET_CAPABILITY_PARTIAL_CONNECTIVITY,
- mWiFiNetworkAgent);
+ mWiFiAgent);
}
mCm.unregisterNetworkCallback(wifiNetworkCallback);
// Wi-Fi roams from wifiNc1 to wifiNc2, and now becomes really invalid. If validation
// failures after roam are not ignored, this will cause cell to become the default network.
// If they are ignored, this will not cause a switch until later.
- mWiFiNetworkAgent.setNetworkCapabilities(wifiNc2, true);
- mDefaultNetworkCallback.expect(NETWORK_CAPS_UPDATED, mWiFiNetworkAgent);
- mWiFiNetworkAgent.setNetworkInvalid(false /* invalidBecauseOfPrivateDns */);
- mCm.reportNetworkConnectivity(mWiFiNetworkAgent.getNetwork(), false);
+ mWiFiAgent.setNetworkCapabilities(wifiNc2, true);
+ mDefaultNetworkCallback.expect(NETWORK_CAPS_UPDATED, mWiFiAgent);
+ mWiFiAgent.setNetworkInvalid(false /* invalidBecauseOfPrivateDns */);
+ mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), false);
if (enabled) {
// Network validation failed, but the result will be ignored.
- assertTrue(mCm.getNetworkCapabilities(mWiFiNetworkAgent.getNetwork()).hasCapability(
+ assertTrue(mCm.getNetworkCapabilities(mWiFiAgent.getNetwork()).hasCapability(
NET_CAPABILITY_VALIDATED));
- mWiFiNetworkAgent.setNetworkValid(false);
+ mWiFiAgent.setNetworkValid(false);
// Behavior of after config_validationFailureAfterRoamIgnoreTimeMillis
ConditionVariable waitForValidationBlock = new ConditionVariable();
doReturn(50).when(mResources)
.getInteger(R.integer.config_validationFailureAfterRoamIgnoreTimeMillis);
// Wi-Fi roaming from wifiNc2 to wifiNc1.
- mWiFiNetworkAgent.setNetworkCapabilities(wifiNc1, true);
- mWiFiNetworkAgent.setNetworkInvalid(false);
+ mWiFiAgent.setNetworkCapabilities(wifiNc1, true);
+ mWiFiAgent.setNetworkInvalid(false);
waitForValidationBlock.block(150);
- mCm.reportNetworkConnectivity(mWiFiNetworkAgent.getNetwork(), false);
- mDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), false);
+ mDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellAgent);
} else {
- mDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellNetworkAgent);
+ mDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellAgent);
}
// Wi-Fi is still connected and would become the default network if cell were to
// disconnect. This assertion ensures that the switch to cellular was not caused by
// Wi-Fi disconnecting (e.g., because the capability change to wifiNc2 caused it
// to stop satisfying the default request).
- mCellNetworkAgent.disconnect();
- mDefaultNetworkCallback.expect(LOST, mCellNetworkAgent);
- mDefaultNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiNetworkAgent);
+ mCellAgent.disconnect();
+ mDefaultNetworkCallback.expect(LOST, mCellAgent);
+ mDefaultNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
}
@@ -17304,8 +17242,8 @@
lp.setInterfaceName(WIFI_IFNAME);
lp.setMtu(mtu);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
- mWiFiNetworkAgent.sendLinkProperties(lp);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.sendLinkProperties(lp);
waitForIdle();
verify(mMockNetd).interfaceSetMtu(eq(WIFI_IFNAME), eq(mtu));
@@ -17318,12 +17256,12 @@
lp.setInterfaceName(WIFI_IFNAME);
lp.setMtu(mtu);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, lp);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, lp);
LinkProperties lp2 = new LinkProperties(lp);
lp2.setMtu(mtu2);
- mWiFiNetworkAgent.sendLinkProperties(lp2);
+ mWiFiAgent.sendLinkProperties(lp2);
waitForIdle();
verify(mMockNetd).interfaceSetMtu(eq(WIFI_IFNAME), eq(mtu2));
@@ -17336,8 +17274,8 @@
lp.setInterfaceName(WIFI_IFNAME);
lp.setMtu(mtu);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, lp);
- mWiFiNetworkAgent.sendLinkProperties(new LinkProperties(lp));
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, lp);
+ mWiFiAgent.sendLinkProperties(new LinkProperties(lp));
waitForIdle();
verify(mMockNetd, never()).interfaceSetMtu(eq(WIFI_IFNAME), anyInt());
@@ -17350,13 +17288,13 @@
lp.setInterfaceName(WIFI_IFNAME);
lp.setMtu(mtu);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, lp);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, lp);
LinkProperties lp2 = new LinkProperties();
assertNull(lp2.getInterfaceName());
lp2.setMtu(mtu);
- mWiFiNetworkAgent.sendLinkProperties(new LinkProperties(lp2));
+ mWiFiAgent.sendLinkProperties(new LinkProperties(lp2));
waitForIdle();
verify(mMockNetd, never()).interfaceSetMtu(any(), anyInt());
@@ -17369,14 +17307,14 @@
lp.setInterfaceName(WIFI_IFNAME);
lp.setMtu(mtu);
- mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, lp);
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, lp);
final String ifaceName2 = WIFI_IFNAME + "_2";
LinkProperties lp2 = new LinkProperties();
lp2.setInterfaceName(ifaceName2);
lp2.setMtu(mtu);
- mWiFiNetworkAgent.sendLinkProperties(new LinkProperties(lp2));
+ mWiFiAgent.sendLinkProperties(new LinkProperties(lp2));
waitForIdle();
verify(mMockNetd).interfaceSetMtu(eq(ifaceName2), eq(mtu));
diff --git a/tests/unit/java/com/android/server/NsdServiceTest.java b/tests/unit/java/com/android/server/NsdServiceTest.java
index 58a1a4f..a1c865f 100644
--- a/tests/unit/java/com/android/server/NsdServiceTest.java
+++ b/tests/unit/java/com/android/server/NsdServiceTest.java
@@ -28,6 +28,7 @@
import static org.junit.Assert.assertNull;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.Mockito.any;
import static org.mockito.Mockito.doCallRealMethod;
import static org.mockito.Mockito.doReturn;
@@ -45,6 +46,7 @@
import android.content.Context;
import android.net.INetd;
import android.net.InetAddresses;
+import android.net.Network;
import android.net.mdns.aidl.DiscoveryInfo;
import android.net.mdns.aidl.GetAddressInfo;
import android.net.mdns.aidl.IMDnsEventListener;
@@ -70,6 +72,10 @@
import androidx.test.filters.SmallTest;
import com.android.server.NsdService.Dependencies;
+import com.android.server.connectivity.mdns.MdnsDiscoveryManager;
+import com.android.server.connectivity.mdns.MdnsServiceBrowserListener;
+import com.android.server.connectivity.mdns.MdnsServiceInfo;
+import com.android.server.connectivity.mdns.MdnsSocketProvider;
import com.android.testutils.DevSdkIgnoreRule;
import com.android.testutils.DevSdkIgnoreRunner;
import com.android.testutils.HandlerUtils;
@@ -86,6 +92,7 @@
import org.mockito.MockitoAnnotations;
import java.util.LinkedList;
+import java.util.List;
import java.util.Queue;
// TODOs:
@@ -99,7 +106,7 @@
private static final long CLEANUP_DELAY_MS = 500;
private static final long TIMEOUT_MS = 500;
private static final String SERVICE_NAME = "a_name";
- private static final String SERVICE_TYPE = "a_type";
+ private static final String SERVICE_TYPE = "_test._tcp";
private static final String SERVICE_FULL_NAME = SERVICE_NAME + "." + SERVICE_TYPE;
private static final String DOMAIN_NAME = "mytestdevice.local";
private static final int PORT = 2201;
@@ -116,6 +123,8 @@
@Mock ContentResolver mResolver;
@Mock MDnsManager mMockMDnsM;
@Mock Dependencies mDeps;
+ @Mock MdnsDiscoveryManager mDiscoveryManager;
+ @Mock MdnsSocketProvider mSocketProvider;
HandlerThread mThread;
TestHandler mHandler;
NsdService mService;
@@ -558,6 +567,16 @@
anyInt()/* interfaceIdx */);
}
+ private void makeServiceWithMdnsDiscoveryManagerEnabled() {
+ doReturn(true).when(mDeps).isMdnsDiscoveryManagerEnabled(any(Context.class));
+ doReturn(mDiscoveryManager).when(mDeps).makeMdnsDiscoveryManager(any(), any());
+ doReturn(mSocketProvider).when(mDeps).makeMdnsSocketProvider(any(), any());
+
+ mService = makeService();
+ verify(mDeps).makeMdnsDiscoveryManager(any(), any());
+ verify(mDeps).makeMdnsSocketProvider(any(), any());
+ }
+
@Test
public void testMdnsDiscoveryManagerFeature() {
// Create NsdService w/o feature enabled.
@@ -566,12 +585,102 @@
verify(mDeps, never()).makeMdnsSocketProvider(any(), any());
// Create NsdService again w/ feature enabled.
- doReturn(true).when(mDeps).isMdnsDiscoveryManagerEnabled(any(Context.class));
- makeService();
- verify(mDeps).makeMdnsDiscoveryManager(any(), any());
- verify(mDeps).makeMdnsSocketProvider(any(), any());
+ makeServiceWithMdnsDiscoveryManagerEnabled();
}
+ @Test
+ public void testDiscoveryWithMdnsDiscoveryManager() {
+ makeServiceWithMdnsDiscoveryManagerEnabled();
+
+ final NsdManager client = connectClient(mService);
+ final DiscoveryListener discListener = mock(DiscoveryListener.class);
+ final Network network = new Network(999);
+ final String serviceTypeWithLocalDomain = SERVICE_TYPE + ".local";
+ // Verify the discovery start / stop.
+ final ArgumentCaptor<MdnsServiceBrowserListener> listenerCaptor =
+ ArgumentCaptor.forClass(MdnsServiceBrowserListener.class);
+ client.discoverServices(SERVICE_TYPE, PROTOCOL, network, r -> r.run(), discListener);
+ waitForIdle();
+ verify(mSocketProvider).startMonitoringSockets();
+ verify(mDiscoveryManager).registerListener(eq(serviceTypeWithLocalDomain),
+ listenerCaptor.capture(), argThat(options -> network.equals(options.getNetwork())));
+ verify(discListener, timeout(TIMEOUT_MS)).onDiscoveryStarted(SERVICE_TYPE);
+
+ final MdnsServiceBrowserListener listener = listenerCaptor.getValue();
+ final MdnsServiceInfo foundInfo = new MdnsServiceInfo(
+ SERVICE_NAME, /* serviceInstanceName */
+ serviceTypeWithLocalDomain.split("\\."), /* serviceType */
+ List.of(), /* subtypes */
+ new String[] {"android", "local"}, /* hostName */
+ 12345, /* port */
+ "192.0.2.0", /* ipv4Address */
+ "2001:db8::", /* ipv6Address */
+ List.of(), /* textStrings */
+ List.of(), /* textEntries */
+ 1234, /* interfaceIndex */
+ network);
+
+ // Verify onServiceNameDiscovered callback
+ listener.onServiceNameDiscovered(foundInfo);
+ verify(discListener, timeout(TIMEOUT_MS)).onServiceFound(argThat(info ->
+ info.getServiceName().equals(SERVICE_NAME)
+ && info.getServiceType().equals(SERVICE_TYPE)
+ && info.getNetwork().equals(network)));
+
+ final MdnsServiceInfo removedInfo = new MdnsServiceInfo(
+ SERVICE_NAME, /* serviceInstanceName */
+ serviceTypeWithLocalDomain.split("\\."), /* serviceType */
+ null, /* subtypes */
+ null, /* hostName */
+ 0, /* port */
+ null, /* ipv4Address */
+ null, /* ipv6Address */
+ null, /* textStrings */
+ null, /* textEntries */
+ 1234, /* interfaceIndex */
+ network);
+ // Verify onServiceNameRemoved callback
+ listener.onServiceNameRemoved(removedInfo);
+ verify(discListener, timeout(TIMEOUT_MS)).onServiceLost(argThat(info ->
+ info.getServiceName().equals(SERVICE_NAME)
+ && info.getServiceType().equals(SERVICE_TYPE)
+ && info.getNetwork().equals(network)));
+
+ client.stopServiceDiscovery(discListener);
+ waitForIdle();
+ verify(mDiscoveryManager).unregisterListener(eq(serviceTypeWithLocalDomain), any());
+ verify(discListener, timeout(TIMEOUT_MS)).onDiscoveryStopped(SERVICE_TYPE);
+ verify(mSocketProvider, timeout(CLEANUP_DELAY_MS + TIMEOUT_MS)).stopMonitoringSockets();
+ }
+
+ @Test
+ public void testDiscoveryWithMdnsDiscoveryManager_FailedWithInvalidServiceType() {
+ makeServiceWithMdnsDiscoveryManagerEnabled();
+
+ final NsdManager client = connectClient(mService);
+ final DiscoveryListener discListener = mock(DiscoveryListener.class);
+ final Network network = new Network(999);
+ final String invalidServiceType = "a_service";
+ client.discoverServices(
+ invalidServiceType, PROTOCOL, network, r -> r.run(), discListener);
+ waitForIdle();
+ verify(discListener, timeout(TIMEOUT_MS))
+ .onStartDiscoveryFailed(invalidServiceType, FAILURE_INTERNAL_ERROR);
+
+ final String serviceTypeWithLocalDomain = SERVICE_TYPE + ".local";
+ client.discoverServices(
+ serviceTypeWithLocalDomain, PROTOCOL, network, r -> r.run(), discListener);
+ waitForIdle();
+ verify(discListener, timeout(TIMEOUT_MS))
+ .onStartDiscoveryFailed(serviceTypeWithLocalDomain, FAILURE_INTERNAL_ERROR);
+
+ final String serviceTypeWithoutTcpOrUdpEnding = "_test._com";
+ client.discoverServices(
+ serviceTypeWithoutTcpOrUdpEnding, PROTOCOL, network, r -> r.run(), discListener);
+ waitForIdle();
+ verify(discListener, timeout(TIMEOUT_MS))
+ .onStartDiscoveryFailed(serviceTypeWithoutTcpOrUdpEnding, FAILURE_INTERNAL_ERROR);
+ }
private void waitForIdle() {
HandlerUtils.waitForIdle(mHandler, TIMEOUT_MS);
diff --git a/tests/unit/java/com/android/server/connectivity/KeepaliveTrackerTest.java b/tests/unit/java/com/android/server/connectivity/KeepaliveTrackerTest.java
new file mode 100644
index 0000000..b55ee67
--- /dev/null
+++ b/tests/unit/java/com/android/server/connectivity/KeepaliveTrackerTest.java
@@ -0,0 +1,243 @@
+/*
+ * Copyright (C) 2022 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 com.android.server.connectivity;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.net.INetd;
+import android.net.MarkMaskParcel;
+import android.os.Build;
+import android.os.HandlerThread;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import com.android.connectivity.resources.R;
+import com.android.testutils.DevSdkIgnoreRule;
+import com.android.testutils.DevSdkIgnoreRunner;
+
+import libcore.util.HexEncoding;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+@RunWith(DevSdkIgnoreRunner.class)
+@SmallTest
+@DevSdkIgnoreRule.IgnoreUpTo(Build.VERSION_CODES.R)
+public class KeepaliveTrackerTest {
+ private static final int[] TEST_SUPPORTED_KEEPALIVES = {1, 3, 0, 0, 0, 0, 0, 0, 0};
+ private static final int TEST_NETID = 0xA85;
+ private static final int TEST_NETID_FWMARK = 0x0A85;
+ private static final int OTHER_NETID = 0x1A85;
+ private static final int NETID_MASK = 0xffff;
+ private static final int SUPPORTED_SLOT_COUNT = 2;
+ private KeepaliveTracker mKeepaliveTracker;
+ private HandlerThread mHandlerThread;
+
+ @Mock INetd mNetd;
+ @Mock KeepaliveTracker.Dependencies mDependencies;
+ @Mock Context mCtx;
+ @Mock Resources mResources;
+
+ // Hexadecimal representation of a SOCK_DIAG response with tcp info.
+ private static final String SOCK_DIAG_TCP_INET_HEX =
+ // struct nlmsghdr.
+ "14010000" + // length = 276
+ "1400" + // type = SOCK_DIAG_BY_FAMILY
+ "0301" + // flags = NLM_F_REQUEST | NLM_F_DUMP
+ "00000000" + // seqno
+ "00000000" + // pid (0 == kernel)
+ // struct inet_diag_req_v2
+ "02" + // family = AF_INET
+ "06" + // state
+ "00" + // timer
+ "00" + // retrans
+ // inet_diag_sockid
+ "DEA5" + // idiag_sport = 42462
+ "71B9" + // idiag_dport = 47473
+ "0a006402000000000000000000000000" + // idiag_src = 10.0.100.2
+ "08080808000000000000000000000000" + // idiag_dst = 8.8.8.8
+ "00000000" + // idiag_if
+ "34ED000076270000" + // idiag_cookie = 43387759684916
+ "00000000" + // idiag_expires
+ "00000000" + // idiag_rqueue
+ "00000000" + // idiag_wqueue
+ "00000000" + // idiag_uid
+ "00000000" + // idiag_inode
+ // rtattr
+ "0500" + // len = 5
+ "0800" + // type = 8
+ "00000000" + // data
+ "0800" + // len = 8
+ "0F00" + // type = 15(INET_DIAG_MARK)
+ "850A0C00" + // data, socket mark=789125
+ "AC00" + // len = 172
+ "0200" + // type = 2(INET_DIAG_INFO)
+ // tcp_info
+ "01" + // state = TCP_ESTABLISHED
+ "00" + // ca_state = TCP_CA_OPEN
+ "05" + // retransmits = 5
+ "00" + // probes = 0
+ "00" + // backoff = 0
+ "07" + // option = TCPI_OPT_WSCALE|TCPI_OPT_SACK|TCPI_OPT_TIMESTAMPS
+ "88" + // wscale = 8
+ "00" + // delivery_rate_app_limited = 0
+ "4A911B00" + // rto = 1806666
+ "00000000" + // ato = 0
+ "2E050000" + // sndMss = 1326
+ "18020000" + // rcvMss = 536
+ "00000000" + // unsacked = 0
+ "00000000" + // acked = 0
+ "00000000" + // lost = 0
+ "00000000" + // retrans = 0
+ "00000000" + // fackets = 0
+ "BB000000" + // lastDataSent = 187
+ "00000000" + // lastAckSent = 0
+ "BB000000" + // lastDataRecv = 187
+ "BB000000" + // lastDataAckRecv = 187
+ "DC050000" + // pmtu = 1500
+ "30560100" + // rcvSsthresh = 87600
+ "3E2C0900" + // rttt = 601150
+ "1F960400" + // rttvar = 300575
+ "78050000" + // sndSsthresh = 1400
+ "0A000000" + // sndCwnd = 10
+ "A8050000" + // advmss = 1448
+ "03000000" + // reordering = 3
+ "00000000" + // rcvrtt = 0
+ "30560100" + // rcvspace = 87600
+ "00000000" + // totalRetrans = 0
+ "53AC000000000000" + // pacingRate = 44115
+ "FFFFFFFFFFFFFFFF" + // maxPacingRate = 18446744073709551615
+ "0100000000000000" + // bytesAcked = 1
+ "0000000000000000" + // bytesReceived = 0
+ "0A000000" + // SegsOut = 10
+ "00000000" + // SegsIn = 0
+ "00000000" + // NotSentBytes = 0
+ "3E2C0900" + // minRtt = 601150
+ "00000000" + // DataSegsIn = 0
+ "00000000" + // DataSegsOut = 0
+ "0000000000000000"; // deliverRate = 0
+ private static final String SOCK_DIAG_NO_TCP_INET_HEX =
+ // struct nlmsghdr
+ "14000000" // length = 20
+ + "0300" // type = NLMSG_DONE
+ + "0301" // flags = NLM_F_REQUEST | NLM_F_DUMP
+ + "00000000" // seqno
+ + "00000000" // pid (0 == kernel)
+ // struct inet_diag_req_v2
+ + "02" // family = AF_INET
+ + "06" // state
+ + "00" // timer
+ + "00"; // retrans
+ private static final byte[] SOCK_DIAG_NO_TCP_INET_BYTES =
+ HexEncoding.decode(SOCK_DIAG_NO_TCP_INET_HEX.toCharArray(), false);
+ private static final String TEST_RESPONSE_HEX =
+ SOCK_DIAG_TCP_INET_HEX + SOCK_DIAG_NO_TCP_INET_HEX;
+ private static final byte[] TEST_RESPONSE_BYTES =
+ HexEncoding.decode(TEST_RESPONSE_HEX.toCharArray(), false);
+
+ @Before
+ public void setup() throws Exception {
+ MockitoAnnotations.initMocks(this);
+
+ doReturn(mNetd).when(mDependencies).getNetd();
+ doReturn(makeMarkMaskParcel(NETID_MASK, TEST_NETID_FWMARK)).when(mNetd)
+ .getFwmarkForNetwork(TEST_NETID);
+
+ doReturn(TEST_SUPPORTED_KEEPALIVES).when(mDependencies).getSupportedKeepalives();
+ doReturn(mResources).when(mDependencies).newConnectivityResources();
+ mockResource();
+ doNothing().when(mDependencies).sendRequest(any(), any());
+
+ mHandlerThread = new HandlerThread("KeepaliveTrackerTest");
+ mHandlerThread.start();
+
+ mKeepaliveTracker = new KeepaliveTracker(mCtx, mHandlerThread.getThreadHandler(),
+ mDependencies);
+ }
+
+ private void mockResource() {
+ doReturn(SUPPORTED_SLOT_COUNT).when(mResources).getInteger(
+ R.integer.config_reservedPrivilegedKeepaliveSlots);
+ doReturn(SUPPORTED_SLOT_COUNT).when(mResources).getInteger(
+ R.integer.config_allowedUnprivilegedKeepalivePerUid);
+ }
+
+ @Test
+ public void testIsAnyTcpSocketConnected_runOnNonHandlerThread() throws Exception {
+ setupResponseWithSocketExisting();
+ assertThrows(IllegalStateException.class,
+ () -> mKeepaliveTracker.isAnyTcpSocketConnected(TEST_NETID));
+ }
+
+ @Test
+ public void testIsAnyTcpSocketConnected_withTargetNetId() throws Exception {
+ setupResponseWithSocketExisting();
+ mHandlerThread.getThreadHandler().post(
+ () -> assertTrue(mKeepaliveTracker.isAnyTcpSocketConnected(TEST_NETID)));
+ }
+
+ @Test
+ public void testIsAnyTcpSocketConnected_withIncorrectNetId() throws Exception {
+ setupResponseWithSocketExisting();
+ mHandlerThread.getThreadHandler().post(
+ () -> assertFalse(mKeepaliveTracker.isAnyTcpSocketConnected(OTHER_NETID)));
+ }
+
+ @Test
+ public void testIsAnyTcpSocketConnected_noSocketExists() throws Exception {
+ setupResponseWithoutSocketExisting();
+ mHandlerThread.getThreadHandler().post(
+ () -> assertFalse(mKeepaliveTracker.isAnyTcpSocketConnected(TEST_NETID)));
+ }
+
+ private void setupResponseWithSocketExisting() throws Exception {
+ final ByteBuffer tcpBufferV6 = getByteBuffer(TEST_RESPONSE_BYTES);
+ final ByteBuffer tcpBufferV4 = getByteBuffer(TEST_RESPONSE_BYTES);
+ doReturn(tcpBufferV6, tcpBufferV4).when(mDependencies).recvSockDiagResponse(any());
+ }
+
+ private void setupResponseWithoutSocketExisting() throws Exception {
+ final ByteBuffer tcpBufferV6 = getByteBuffer(SOCK_DIAG_NO_TCP_INET_BYTES);
+ final ByteBuffer tcpBufferV4 = getByteBuffer(SOCK_DIAG_NO_TCP_INET_BYTES);
+ doReturn(tcpBufferV6, tcpBufferV4).when(mDependencies).recvSockDiagResponse(any());
+ }
+
+ private MarkMaskParcel makeMarkMaskParcel(final int mask, final int mark) {
+ final MarkMaskParcel parcel = new MarkMaskParcel();
+ parcel.mask = mask;
+ parcel.mark = mark;
+ return parcel;
+ }
+
+ private ByteBuffer getByteBuffer(final byte[] bytes) {
+ final ByteBuffer buffer = ByteBuffer.wrap(bytes);
+ buffer.order(ByteOrder.nativeOrder());
+ return buffer;
+ }
+}