Add WifiPickerTracker.getActiveWifiEntries()
Add getActiveWifiEntries() to return all connected/connecting
WifiEntries, including the primary network and any secondary OEM
networks. For backwards compatibility, getConnectedWifiEntry() will
continue to return the connected/connecting primary network.
Bug: 233925075
Test: atest WifiTrackerLibTests
Change-Id: Ied827b000a70db15011023df4aaa1836d3393499
diff --git a/libs/WifiTrackerLib/src/com/android/wifitrackerlib/WifiEntry.java b/libs/WifiTrackerLib/src/com/android/wifitrackerlib/WifiEntry.java
index d3cdc49..0fa20a0 100644
--- a/libs/WifiTrackerLib/src/com/android/wifitrackerlib/WifiEntry.java
+++ b/libs/WifiTrackerLib/src/com/android/wifitrackerlib/WifiEntry.java
@@ -207,8 +207,9 @@
* Default comparator for sorting WifiEntries on a Wi-Fi picker list.
*/
public static Comparator<WifiEntry> WIFI_PICKER_COMPARATOR =
- Comparator.comparing((WifiEntry entry) -> entry.getConnectedState()
- != CONNECTED_STATE_CONNECTED)
+ Comparator.comparing((WifiEntry entry) -> !entry.isPrimaryNetwork())
+ .thenComparing((WifiEntry entry) ->
+ entry.getConnectedState() != CONNECTED_STATE_CONNECTED)
.thenComparing((WifiEntry entry) -> !entry.canConnect())
.thenComparing((WifiEntry entry) -> !entry.isSubscription())
.thenComparing((WifiEntry entry) -> !entry.isSaved())
@@ -336,7 +337,8 @@
return getConnectedState() != CONNECTED_STATE_DISCONNECTED
&& mConnectivityReport != null
&& (!hasInternetAccess() || !mIsDefaultNetwork)
- && !canSignIn();
+ && !canSignIn()
+ && isPrimaryNetwork();
}
/**
@@ -357,9 +359,22 @@
}
/**
+ * Returns whether this network is the primary Wi-Fi network or not.
+ */
+ public boolean isPrimaryNetwork() {
+ if (mWifiInfo == null) {
+ return false;
+ }
+ return NonSdkApiWrapper.isPrimary(mWifiInfo);
+ }
+
+ /**
* Returns whether this network is considered low quality.
*/
public boolean isLowQuality() {
+ if (!isPrimaryNetwork()) {
+ return false;
+ }
if (mNetworkCapabilities == null) {
return false;
}
@@ -881,8 +896,10 @@
return;
}
- // Treat non-primary connections as disconnected.
- if (!NonSdkApiWrapper.isPrimary(wifiInfo)) {
+ // Treat non-primary, non-OEM connections as disconnected.
+ if (!NonSdkApiWrapper.isPrimary(wifiInfo)
+ && !capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_OEM_PAID)
+ && !capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_OEM_PRIVATE)) {
onNetworkLost(network);
return;
}
@@ -1147,8 +1164,10 @@
.append(getConnectedInfo())
.append(",hasInternet:")
.append(hasInternetAccess())
- .append(",isDefaultNetwork:")
+ .append(",isDefault:")
.append(mIsDefaultNetwork)
+ .append(",isPrimary:")
+ .append(isPrimaryNetwork())
.toString();
}
diff --git a/libs/WifiTrackerLib/src/com/android/wifitrackerlib/WifiPickerTracker.java b/libs/WifiTrackerLib/src/com/android/wifitrackerlib/WifiPickerTracker.java
index 61a77bf..f8e01dc 100644
--- a/libs/WifiTrackerLib/src/com/android/wifitrackerlib/WifiPickerTracker.java
+++ b/libs/WifiTrackerLib/src/com/android/wifitrackerlib/WifiPickerTracker.java
@@ -22,8 +22,6 @@
import static com.android.wifitrackerlib.PasspointWifiEntry.uniqueIdToPasspointWifiEntryKey;
import static com.android.wifitrackerlib.StandardWifiEntry.ScanResultKey;
import static com.android.wifitrackerlib.StandardWifiEntry.StandardWifiEntryKey;
-import static com.android.wifitrackerlib.WifiEntry.CONNECTED_STATE_CONNECTED;
-import static com.android.wifitrackerlib.WifiEntry.CONNECTED_STATE_CONNECTING;
import static com.android.wifitrackerlib.WifiEntry.CONNECTED_STATE_DISCONNECTED;
import static com.android.wifitrackerlib.WifiEntry.WIFI_LEVEL_UNREACHABLE;
@@ -90,10 +88,12 @@
// Lock object for data returned by the public API
private final Object mLock = new Object();
- // List representing return value of the getWifiEntries() API
- @GuardedBy("mLock") private final List<WifiEntry> mWifiEntries = new ArrayList<>();
- // Reference to the WifiEntry representing the network that is currently connected to
- private WifiEntry mConnectedWifiEntry;
+ // List representing the return value of the getActiveWifiEntries() API
+ @GuardedBy("mLock")
+ @NonNull private final List<WifiEntry> mActiveWifiEntries = new ArrayList<>();
+ // List representing the return value of the getWifiEntries() API
+ @GuardedBy("mLock")
+ @NonNull private final List<WifiEntry> mWifiEntries = new ArrayList<>();
// NetworkRequestEntry representing a network that was connected through the NetworkRequest API
private NetworkRequestEntry mNetworkRequestEntry;
@@ -171,15 +171,36 @@
}
/**
- * Returns the WifiEntry representing the current connection.
+ * Returns the WifiEntry representing the current primary connection.
*/
@AnyThread
public @Nullable WifiEntry getConnectedWifiEntry() {
- return mConnectedWifiEntry;
+ synchronized (mLock) {
+ if (mActiveWifiEntries.isEmpty()) {
+ return null;
+ }
+ // Primary entry is sorted to be first.
+ WifiEntry primaryWifiEntry = mActiveWifiEntries.get(0);
+ if (!primaryWifiEntry.isPrimaryNetwork()) {
+ return null;
+ }
+ return primaryWifiEntry;
+ }
}
/**
- * Returns a list of in-range WifiEntries.
+ * Returns a list of all connected/connecting Wi-Fi entries, including the primary and any
+ * secondary connections.
+ */
+ @AnyThread
+ public @NonNull List<WifiEntry> getActiveWifiEntries() {
+ synchronized (mLock) {
+ return new ArrayList<>(mActiveWifiEntries);
+ }
+ }
+
+ /**
+ * Returns a list of disconnected, in-range WifiEntries.
*
* The currently connected entry is omitted and may be accessed through
* {@link #getConnectedWifiEntry()}
@@ -241,7 +262,6 @@
}
private void clearAllWifiEntries() {
- mConnectedWifiEntry = null;
mStandardWifiEntryCache.clear();
mSuggestedWifiEntryCache.clear();
mPasspointWifiEntryCache.clear();
@@ -408,34 +428,21 @@
@WorkerThread
protected void updateWifiEntries() {
synchronized (mLock) {
- mConnectedWifiEntry = mStandardWifiEntryCache.stream().filter(entry -> {
- final @WifiEntry.ConnectedState int connectedState = entry.getConnectedState();
- return connectedState == CONNECTED_STATE_CONNECTED
- || connectedState == CONNECTED_STATE_CONNECTING;
- }).findAny().orElse(null /* other */);
- if (mConnectedWifiEntry == null) {
- mConnectedWifiEntry = mSuggestedWifiEntryCache.stream().filter(entry -> {
- final @WifiEntry.ConnectedState int connectedState = entry.getConnectedState();
- return connectedState == CONNECTED_STATE_CONNECTED
- || connectedState == CONNECTED_STATE_CONNECTING;
- }).findAny().orElse(null /* other */);
+ mActiveWifiEntries.clear();
+ mActiveWifiEntries.addAll(mStandardWifiEntryCache);
+ mActiveWifiEntries.addAll(mSuggestedWifiEntryCache);
+ mActiveWifiEntries.addAll(mPasspointWifiEntryCache.values());
+ if (mNetworkRequestEntry != null) {
+ mActiveWifiEntries.add(mNetworkRequestEntry);
}
- if (mConnectedWifiEntry == null) {
- mConnectedWifiEntry = mPasspointWifiEntryCache.values().stream().filter(entry -> {
- final @WifiEntry.ConnectedState int connectedState = entry.getConnectedState();
- return connectedState == CONNECTED_STATE_CONNECTED
- || connectedState == CONNECTED_STATE_CONNECTING;
- }).findAny().orElse(null /* other */);
- }
- if (mConnectedWifiEntry == null && mNetworkRequestEntry != null
- && mNetworkRequestEntry.getConnectedState() != CONNECTED_STATE_DISCONNECTED) {
- mConnectedWifiEntry = mNetworkRequestEntry;
- }
+ mActiveWifiEntries.removeIf(entry ->
+ entry.getConnectedState() == CONNECTED_STATE_DISCONNECTED);
+ mActiveWifiEntries.sort(WifiEntry.WIFI_PICKER_COMPARATOR);
mWifiEntries.clear();
final Set<ScanResultKey> scanResultKeysWithVisibleSuggestions =
mSuggestedWifiEntryCache.stream()
.filter(entry -> entry.isUserShareable()
- || entry == mConnectedWifiEntry)
+ || mActiveWifiEntries.contains(entry))
.map(entry -> entry.getStandardWifiEntryKey().getScanResultKey())
.collect(Collectors.toSet());
Set<String> passpointUtf8Ssids = new ArraySet<>();
@@ -444,7 +451,7 @@
}
for (StandardWifiEntry entry : mStandardWifiEntryCache) {
entry.updateAdminRestrictions();
- if (entry == mConnectedWifiEntry) {
+ if (mActiveWifiEntries.contains(entry)) {
continue;
}
if (!entry.isSaved()) {
@@ -471,7 +478,8 @@
entry.getConnectedState() == CONNECTED_STATE_DISCONNECTED).collect(toList()));
Collections.sort(mWifiEntries, WifiEntry.WIFI_PICKER_COMPARATOR);
if (isVerboseLoggingEnabled()) {
- Log.v(TAG, "Connected WifiEntry: " + mConnectedWifiEntry);
+ Log.v(TAG, "Connected WifiEntries: "
+ + Arrays.toString(mActiveWifiEntries.toArray()));
Log.v(TAG, "Updated WifiEntries: " + Arrays.toString(mWifiEntries.toArray()));
}
}
diff --git a/libs/WifiTrackerLib/tests/src/com/android/wifitrackerlib/StandardWifiEntryTest.java b/libs/WifiTrackerLib/tests/src/com/android/wifitrackerlib/StandardWifiEntryTest.java
index 35ee254..ce5e534 100644
--- a/libs/WifiTrackerLib/tests/src/com/android/wifitrackerlib/StandardWifiEntryTest.java
+++ b/libs/WifiTrackerLib/tests/src/com/android/wifitrackerlib/StandardWifiEntryTest.java
@@ -449,6 +449,52 @@
}
@Test
+ public void testOnNetworkCapabilitiesChanged_nonPrimaryOem_becomesConnected() {
+ final WifiConfiguration config = new WifiConfiguration();
+ config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP);
+ config.SSID = "\"ssid\"";
+ config.networkId = 1;
+ final StandardWifiEntry entry = new StandardWifiEntry(
+ mMockInjector, mMockContext, mTestHandler,
+ ssidAndSecurityTypeToStandardWifiEntryKey("ssid", SECURITY_TYPE_EAP),
+ Collections.singletonList(config), null, mMockWifiManager,
+ false /* forSavedNetworksPage */);
+ when(mMockWifiInfo.getNetworkId()).thenReturn(1);
+ when(mMockWifiInfo.getRssi()).thenReturn(TestUtils.GOOD_RSSI);
+
+ MockitoSession session = mockitoSession().spyStatic(NonSdkApiWrapper.class).startMocking();
+ try {
+ ExtendedMockito.doReturn(false)
+ .when(() -> NonSdkApiWrapper.isPrimary(mMockWifiInfo));
+ // OEM-Paid
+ when(mMockNetworkCapabilities.hasCapability(
+ NetworkCapabilities.NET_CAPABILITY_OEM_PAID)).thenReturn(true);
+ when(mMockNetworkCapabilities.hasCapability(
+ NetworkCapabilities.NET_CAPABILITY_OEM_PRIVATE)).thenReturn(false);
+ entry.onNetworkCapabilitiesChanged(mMockNetwork, mMockNetworkCapabilities);
+ assertThat(entry.getConnectedState()).isEqualTo(CONNECTED_STATE_CONNECTED);
+
+ // OEM-Private
+ when(mMockNetworkCapabilities.hasCapability(
+ NetworkCapabilities.NET_CAPABILITY_OEM_PAID)).thenReturn(false);
+ when(mMockNetworkCapabilities.hasCapability(
+ NetworkCapabilities.NET_CAPABILITY_OEM_PRIVATE)).thenReturn(true);
+ entry.onNetworkCapabilitiesChanged(mMockNetwork, mMockNetworkCapabilities);
+ assertThat(entry.getConnectedState()).isEqualTo(CONNECTED_STATE_CONNECTED);
+
+ // Not OEM anymore
+ when(mMockNetworkCapabilities.hasCapability(
+ NetworkCapabilities.NET_CAPABILITY_OEM_PAID)).thenReturn(false);
+ when(mMockNetworkCapabilities.hasCapability(
+ NetworkCapabilities.NET_CAPABILITY_OEM_PRIVATE)).thenReturn(false);
+ entry.onNetworkCapabilitiesChanged(mMockNetwork, mMockNetworkCapabilities);
+ assertThat(entry.getConnectedState()).isEqualTo(CONNECTED_STATE_DISCONNECTED);
+ } finally {
+ session.finishMocking();
+ }
+ }
+
+ @Test
public void testConnect_savedNetwork_usesSavedConfig() {
final ScanResult scan = buildScanResult("ssid", "bssid", 0, TestUtils.GOOD_RSSI);
final StandardWifiEntry entry = new StandardWifiEntry(
diff --git a/libs/WifiTrackerLib/tests/src/com/android/wifitrackerlib/WifiPickerTrackerTest.java b/libs/WifiTrackerLib/tests/src/com/android/wifitrackerlib/WifiPickerTrackerTest.java
index 4d09651..be924a9 100644
--- a/libs/WifiTrackerLib/tests/src/com/android/wifitrackerlib/WifiPickerTrackerTest.java
+++ b/libs/WifiTrackerLib/tests/src/com/android/wifitrackerlib/WifiPickerTrackerTest.java
@@ -24,6 +24,8 @@
import static com.android.wifitrackerlib.TestUtils.GOOD_RSSI;
import static com.android.wifitrackerlib.TestUtils.buildScanResult;
import static com.android.wifitrackerlib.TestUtils.buildWifiConfiguration;
+import static com.android.wifitrackerlib.WifiEntry.CONNECTED_STATE_CONNECTED;
+import static com.android.wifitrackerlib.WifiEntry.CONNECTED_STATE_DISCONNECTED;
import static com.google.common.truth.Truth.assertThat;
@@ -1475,6 +1477,146 @@
}
/**
+ * Tests that getActiveWifiEntries() returns the connected primary WifiEntry if we start already
+ * connected to a network.
+ */
+ @Test
+ public void testGetActiveWifiEntries_alreadyConnectedOnStart_returnsConnectedEntry() {
+ final WifiPickerTracker wifiPickerTracker = createTestWifiPickerTracker();
+ final WifiConfiguration config = new WifiConfiguration();
+ config.SSID = "\"ssid\"";
+ config.networkId = 1;
+ when(mMockWifiManager.getPrivilegedConfiguredNetworks())
+ .thenReturn(Collections.singletonList(config));
+ when(mMockWifiInfo.getNetworkId()).thenReturn(1);
+ when(mMockWifiInfo.getRssi()).thenReturn(-50);
+
+ wifiPickerTracker.onStart();
+ mTestLooper.dispatchAll();
+
+ assertThat(wifiPickerTracker.getConnectedWifiEntry()).isNotNull();
+ assertThat(wifiPickerTracker.getActiveWifiEntries()).isNotEmpty();
+ assertThat(wifiPickerTracker.getActiveWifiEntries().get(0))
+ .isEqualTo(wifiPickerTracker.getConnectedWifiEntry());
+ }
+
+ /**
+ * Tests that getActiveWifiEntries() returns the connected primary WifiEntry first, and any
+ * secondary OEM networks that are connected.
+ */
+ @Test
+ public void testGetActiveWifiEntries_oemNetworksConnected_returnsPrimaryAndOemNetworks() {
+ final WifiPickerTracker wifiPickerTracker = createTestWifiPickerTracker();
+ final WifiConfiguration primaryConfig = new WifiConfiguration();
+ primaryConfig.SSID = "\"primary\"";
+ primaryConfig.networkId = 1;
+ final WifiConfiguration oemPaidConfig = new WifiConfiguration();
+ oemPaidConfig.SSID = "\"oemPaid\"";
+ oemPaidConfig.networkId = 2;
+ final WifiConfiguration oemPrivateConfig = new WifiConfiguration();
+ oemPrivateConfig.SSID = "\"oemPrivate\"";
+ oemPrivateConfig.networkId = 3;
+ when(mMockWifiManager.getPrivilegedConfiguredNetworks())
+ .thenReturn(Arrays.asList(primaryConfig, oemPaidConfig, oemPrivateConfig));
+ wifiPickerTracker.onStart();
+ mTestLooper.dispatchAll();
+ verify(mMockConnectivityManager).registerNetworkCallback(
+ any(), mNetworkCallbackCaptor.capture(), any());
+
+ MockitoSession session = mockitoSession().spyStatic(NonSdkApiWrapper.class).startMocking();
+ try {
+ // Connect to primary network
+ when(mMockWifiInfo.getNetworkId()).thenReturn(primaryConfig.networkId);
+ when(mMockWifiInfo.getRssi()).thenReturn(-50);
+ doReturn(true).when(() -> NonSdkApiWrapper.isPrimary(mMockWifiInfo));
+ mNetworkCallbackCaptor.getValue().onCapabilitiesChanged(
+ mMockNetwork, mMockNetworkCapabilities);
+
+ // Connect to OEM-Paid network
+ Network oemPaidNetwork = mock(Network.class);
+ NetworkCapabilities oemPaidCapabilities = mock(NetworkCapabilities.class);
+ when(oemPaidCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_OEM_PAID))
+ .thenReturn(true);
+ WifiInfo oemPaidWifiInfo = mock(WifiInfo.class);
+ when(oemPaidWifiInfo.getNetworkId()).thenReturn(oemPaidConfig.networkId);
+ when(oemPaidWifiInfo.getRssi()).thenReturn(-50);
+ doReturn(false).when(() -> NonSdkApiWrapper.isPrimary(oemPaidWifiInfo));
+ when(oemPaidCapabilities.getTransportInfo()).thenReturn(oemPaidWifiInfo);
+ mNetworkCallbackCaptor.getValue().onCapabilitiesChanged(
+ oemPaidNetwork, oemPaidCapabilities);
+
+ // Connect to OEM-Private network
+ Network oemPrivateNetwork = mock(Network.class);
+ NetworkCapabilities oemPrivateCapabilities = mock(NetworkCapabilities.class);
+ when(oemPrivateCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_OEM_PAID))
+ .thenReturn(true);
+ WifiInfo oemPrivateWifiInfo = mock(WifiInfo.class);
+ when(oemPrivateWifiInfo.getNetworkId()).thenReturn(oemPrivateConfig.networkId);
+ when(oemPrivateWifiInfo.getRssi()).thenReturn(-50);
+ doReturn(false).when(() -> NonSdkApiWrapper.isPrimary(oemPrivateWifiInfo));
+ when(oemPrivateCapabilities.getTransportInfo()).thenReturn(oemPrivateWifiInfo);
+ mNetworkCallbackCaptor.getValue().onCapabilitiesChanged(
+ oemPrivateNetwork, oemPrivateCapabilities);
+
+ WifiEntry primaryWifiEntry = wifiPickerTracker.getActiveWifiEntries().get(0);
+ WifiEntry oemPaidWifiEntry = wifiPickerTracker.getActiveWifiEntries().get(1);
+ WifiEntry oemPrivateWifiEntry = wifiPickerTracker.getActiveWifiEntries().get(2);
+
+ // Primary should go first, then the OEM networks in alphabetical title.
+ assertThat(primaryWifiEntry.getTitle()).isEqualTo("primary");
+ assertThat(oemPaidWifiEntry.getTitle()).isEqualTo("oemPaid");
+ assertThat(oemPrivateWifiEntry.getTitle()).isEqualTo("oemPrivate");
+
+ // All entries should be connected
+ assertThat(primaryWifiEntry.getConnectedState()).isEqualTo(CONNECTED_STATE_CONNECTED);
+ assertThat(oemPaidWifiEntry.getConnectedState()).isEqualTo(CONNECTED_STATE_CONNECTED);
+ assertThat(oemPrivateWifiEntry.getConnectedState())
+ .isEqualTo(CONNECTED_STATE_CONNECTED);
+
+ // Only the primary network should be primary
+ assertThat(primaryWifiEntry.isPrimaryNetwork()).isTrue();
+ assertThat(oemPaidWifiEntry.isPrimaryNetwork()).isFalse();
+ assertThat(oemPrivateWifiEntry.isPrimaryNetwork()).isFalse();
+
+ // The primary should be returned in getWifiEntries()
+ assertThat(wifiPickerTracker.getConnectedWifiEntry()).isEqualTo(primaryWifiEntry);
+
+ // Disconnect primary. Secondary OEM networks should not be primary
+ mNetworkCallbackCaptor.getValue().onLost(mMockNetwork);
+ assertThat(wifiPickerTracker.getConnectedWifiEntry()).isNull();
+ assertThat(primaryWifiEntry.getConnectedState())
+ .isEqualTo(CONNECTED_STATE_DISCONNECTED);
+ assertThat(wifiPickerTracker.getActiveWifiEntries())
+ .containsExactly(oemPaidWifiEntry, oemPrivateWifiEntry);
+ assertThat(oemPaidWifiEntry.getConnectedState()).isEqualTo(CONNECTED_STATE_CONNECTED);
+ assertThat(oemPrivateWifiEntry.getConnectedState())
+ .isEqualTo(CONNECTED_STATE_CONNECTED);
+
+ // OEM paid becomes primary.
+ doReturn(true).when(() -> NonSdkApiWrapper.isPrimary(oemPaidWifiInfo));
+ mNetworkCallbackCaptor.getValue().onCapabilitiesChanged(
+ oemPaidNetwork, oemPaidCapabilities);
+ assertThat(wifiPickerTracker.getConnectedWifiEntry()).isEqualTo(oemPaidWifiEntry);
+ assertThat(wifiPickerTracker.getActiveWifiEntries())
+ .containsExactly(oemPaidWifiEntry, oemPrivateWifiEntry);
+ assertThat(oemPaidWifiEntry.isPrimaryNetwork()).isTrue();
+ assertThat(oemPrivateWifiEntry.isPrimaryNetwork()).isFalse();
+
+ // Disconnect the OEM networks.
+ mNetworkCallbackCaptor.getValue().onLost(oemPaidNetwork);
+ mNetworkCallbackCaptor.getValue().onLost(oemPrivateNetwork);
+ assertThat(oemPaidWifiEntry.getConnectedState())
+ .isEqualTo(CONNECTED_STATE_DISCONNECTED);
+ assertThat(oemPrivateWifiEntry.getConnectedState())
+ .isEqualTo(CONNECTED_STATE_DISCONNECTED);
+ assertThat(wifiPickerTracker.getConnectedWifiEntry()).isNull();
+ assertThat(wifiPickerTracker.getActiveWifiEntries()).isEmpty();
+ } finally {
+ session.finishMocking();
+ }
+ }
+
+ /**
* Tests that SCAN_RESULTS_AVAILABLE_ACTION calls WifiManager#getMatchingOsuProviders()
*/
@Test
@@ -1511,7 +1653,7 @@
mBroadcastReceiverCaptor.getValue().onReceive(mMockContext, intent);
assertThat(wifiPickerTracker.getMergedCarrierEntry().getConnectedState())
- .isEqualTo(WifiEntry.CONNECTED_STATE_CONNECTED);
+ .isEqualTo(CONNECTED_STATE_CONNECTED);
}
/**
@@ -1723,7 +1865,7 @@
mDefaultNetworkCallbackCaptor.capture(), any());
MergedCarrierEntry mergedCarrierEntry = wifiPickerTracker.getMergedCarrierEntry();
assertThat(mergedCarrierEntry.getConnectedState())
- .isEqualTo(WifiEntry.CONNECTED_STATE_CONNECTED);
+ .isEqualTo(CONNECTED_STATE_CONNECTED);
// Wifi isn't default yet, so isDefaultNetwork returns false
assertThat(mergedCarrierEntry.isDefaultNetwork()).isFalse();
@@ -1768,7 +1910,7 @@
mMockNetwork, mMockVcnNetworkCapabilities);
MergedCarrierEntry mergedCarrierEntry = wifiPickerTracker.getMergedCarrierEntry();
assertThat(mergedCarrierEntry.getConnectedState())
- .isEqualTo(WifiEntry.CONNECTED_STATE_CONNECTED);
+ .isEqualTo(CONNECTED_STATE_CONNECTED);
// Wifi isn't default yet, so isDefaultNetwork returns false
assertThat(mergedCarrierEntry.isDefaultNetwork()).isFalse();
mDefaultNetworkCallbackCaptor.getValue().onCapabilitiesChanged(mMockNetwork,
