PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Clean up Contextual Wifi card

Browse Source 
Bug: 245854887
Test: m RunSettingsRoboTests
Change-Id: I3b4ccc076a68eadc11e9fb3d2967a34fe0396cf9
This commit is contained in:
Chaohui Wang
2023-11-27 10:38:03 +08:00
parent b76f32ef3e
commit 34c4deb6c9
12 changed files with 12 additions and 449 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
res/drawable/ic_wifi_off.xml
View File

@@ -1,25 +0,0 @@
<!--
~ Copyright (C) 2020 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.
-->
<vector xmlns:android="http://schemas.android.com/apk/res/android"
android:width="24dp"
android:height="24dp"
android:viewportWidth="24"
android:viewportHeight="24"
android:tint="?android:attr/colorControlNormal">
<path
android:fillColor="@android:color/white"
android:pathData="M23,9c-4.11,-4.11 -9.93,-5.43 -15.15,-3.98l9.57,9.57L23,9zM5.76,5.76L2.81,2.81 1.39,4.22l2.52,2.52C2.88,7.37 1.89,8.11 1,9l11,11 2.59,-2.59 5.19,5.19 1.41,-1.41L16,16 5.76,5.76z"/>
</vector>

4
res/values/strings.xml
View File

@@ -2167,12 +2167,8 @@
<!-- Button label to connect to a Wi-Fi network -->
<string name="wifi_connect">Connect</string>
<!-- Turned on notification for Wi-Fi [CHAR LIMIT=40] -->
<string name="wifi_turned_on_message">Wi\u2011Fi turned on</string>
<!-- A notification for connected to a Wi-Fi network [CHAR LIMIT=NONE] -->
<string name="wifi_connected_to_message">Connected to <xliff:g id="network_name" example="MyNetwork">%1$s</xliff:g></string>
<!-- A notification for connecting to a Wi-Fi network [CHAR LIMIT=NONE] -->
<string name="wifi_connecting_to_message">Connecting to <xliff:g id="network_name" example="MyNetwork">%1$s</xliff:g></string>
<!-- Button label to connecting progress to a Wi-Fi network [CHAR LIMIT=20] -->
<string name="wifi_connecting">Connecting\u2026</string>
<!-- Failured notification for connect -->

4
src/com/android/settings/homepage/contextualcards/ContextualCardLoader.java
View File

@@ -18,7 +18,6 @@ package com.android.settings.homepage.contextualcards;
import static com.android.settings.intelligence.ContextualCardProto.ContextualCard.Category.STICKY_VALUE;
import static com.android.settings.slices.CustomSliceRegistry.BLUETOOTH_DEVICES_SLICE_URI;
import static com.android.settings.slices.CustomSliceRegistry.CONTEXTUAL_WIFI_SLICE_URI;
import android.app.settings.SettingsEnums;
import android.content.Context;
@@ -225,8 +224,7 @@ public class ContextualCardLoader extends AsyncLoaderCompat<List<ContextualCard>
}
private boolean isLargeCard(ContextualCard card) {
return card.getSliceUri().equals(CONTEXTUAL_WIFI_SLICE_URI)
|| card.getSliceUri().equals(BLUETOOTH_DEVICES_SLICE_URI);
return card.getSliceUri().equals(BLUETOOTH_DEVICES_SLICE_URI);
}
public interface CardContentLoaderListener {

7
src/com/android/settings/homepage/contextualcards/SettingsContextualCardProvider.java
View File

@@ -32,12 +32,6 @@ public class SettingsContextualCardProvider extends ContextualCardProvider {
@Override
@Nullable
public ContextualCardList getContextualCards() {
final ContextualCard wifiCard =
ContextualCard.newBuilder()
.setSliceUri(CustomSliceRegistry.CONTEXTUAL_WIFI_SLICE_URI.toString())
.setCardName(CustomSliceRegistry.CONTEXTUAL_WIFI_SLICE_URI.toString())
.setCardCategory(ContextualCard.Category.IMPORTANT)
.build();
final ContextualCard connectedDeviceCard =
ContextualCard.newBuilder()
.setSliceUri(CustomSliceRegistry.BLUETOOTH_DEVICES_SLICE_URI.toString())
@@ -71,7 +65,6 @@ public class SettingsContextualCardProvider extends ContextualCardProvider {
.setCardCategory(ContextualCard.Category.IMPORTANT)
.build();
final ContextualCardList cards = ContextualCardList.newBuilder()
.addCard(wifiCard)
.addCard(connectedDeviceCard)
.addCard(lowStorageCard)
.addCard(contextualAdaptiveSleepCard)

11
src/com/android/settings/slices/CustomSliceRegistry.java
View File

@@ -41,7 +41,6 @@ import com.android.settings.network.ProviderModelSlice;
import com.android.settings.network.telephony.MobileDataSlice;
import com.android.settings.notification.zen.ZenModeButtonPreferenceController;
import com.android.settings.wifi.calling.WifiCallingSliceHelper;
import com.android.settings.wifi.slice.ContextualWifiSlice;
import com.android.settings.wifi.slice.WifiSlice;
import com.android.settingslib.media.MediaOutputConstants;
@@ -82,15 +81,6 @@ public class CustomSliceRegistry {
.appendPath("bluetooth_devices")
.build();
/**
* Backing Uri for the Wifi Slice.
*/
public static final Uri CONTEXTUAL_WIFI_SLICE_URI = new Uri.Builder()
.scheme(ContentResolver.SCHEME_CONTENT)
.authority(SettingsSlicesContract.AUTHORITY)
.appendPath(SettingsSlicesContract.PATH_SETTING_ACTION)
.appendPath("contextual_wifi")
.build();
/**
* Slice Uri for Enhanced 4G slice
*/
@@ -321,7 +311,6 @@ public class CustomSliceRegistry {
// Slices for contextual card.
sUriToSlice.put(FACE_ENROLL_SLICE_URI, FaceSetupSlice.class);
sUriToSlice.put(CONTEXTUAL_ADAPTIVE_SLEEP_URI, ContextualAdaptiveSleepSlice.class);
sUriToSlice.put(CONTEXTUAL_WIFI_SLICE_URI, ContextualWifiSlice.class);
sUriToSlice.put(LOW_STORAGE_SLICE_URI, LowStorageSlice.class);
sUriToSlice.put(BLUETOOTH_DEVICES_SLICE_URI, BluetoothDevicesSlice.class);
}

35
src/com/android/settings/wifi/slice/ContextualWifiScanWorker.java
View File

@@ -1,35 +0,0 @@
/*
* Copyright (C) 2019 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.settings.wifi.slice;
import android.content.Context;
import android.net.Uri;
/**
* {@link SliceBackgroundWorker} for Wi-Fi, used by {@link ContextualWifiSlice}.
*/
public class ContextualWifiScanWorker extends WifiScanWorker {
public ContextualWifiScanWorker(Context context, Uri uri) {
super(context, uri);
}
@Override
protected int getApRowCount() {
return ContextualWifiSlice.getApRowCount();
}
}

156
src/com/android/settings/wifi/slice/ContextualWifiSlice.java
View File

@@ -1,156 +0,0 @@
/*
* Copyright (C) 2018 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.settings.wifi.slice;
import android.content.Context;
import android.graphics.drawable.Drawable;
import android.net.ConnectivityManager;
import android.net.NetworkCapabilities;
import android.net.Uri;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.text.TextUtils;
import androidx.annotation.VisibleForTesting;
import androidx.core.graphics.drawable.IconCompat;
import androidx.slice.Slice;
import androidx.slice.builders.ListBuilder;
import com.android.settings.R;
import com.android.settings.Utils;
import com.android.settings.overlay.FeatureFactory;
import com.android.settings.slices.CustomSliceRegistry;
import com.android.settings.slices.CustomSliceable;
import com.android.wifitrackerlib.WifiEntry;
/**
* {@link CustomSliceable} for Wi-Fi, used by contextual homepage.
*/
public class ContextualWifiSlice extends WifiSlice {
@VisibleForTesting
static final int COLLAPSED_ROW_COUNT = 0;
@VisibleForTesting
static long sActiveUiSession = -1000;
@VisibleForTesting
static boolean sApRowCollapsed;
private final ConnectivityManager mConnectivityManager;
public ContextualWifiSlice(Context context) {
super(context);
mConnectivityManager = mContext.getSystemService(ConnectivityManager.class);
}
@Override
public Uri getUri() {
return CustomSliceRegistry.CONTEXTUAL_WIFI_SLICE_URI;
}
@Override
public Slice getSlice() {
final long currentUiSession = FeatureFactory.getFeatureFactory()
.getSlicesFeatureProvider().getUiSessionToken();
if (currentUiSession != sActiveUiSession) {
sActiveUiSession = currentUiSession;
sApRowCollapsed = hasWorkingNetwork();
} else if (!mWifiManager.isWifiEnabled()) {
sApRowCollapsed = false;
}
return super.getSlice();
}
static int getApRowCount() {
return sApRowCollapsed ? COLLAPSED_ROW_COUNT : DEFAULT_EXPANDED_ROW_COUNT;
}
@Override
protected boolean isApRowCollapsed() {
return sApRowCollapsed;
}
@Override
protected ListBuilder.RowBuilder getHeaderRow(boolean isWifiEnabled,
WifiSliceItem wifiSliceItem) {
final ListBuilder.RowBuilder builder = super.getHeaderRow(isWifiEnabled, wifiSliceItem);
builder.setTitleItem(getHeaderIcon(isWifiEnabled, wifiSliceItem), ListBuilder.ICON_IMAGE);
if (sApRowCollapsed) {
builder.setSubtitle(getHeaderSubtitle(wifiSliceItem));
}
return builder;
}
private IconCompat getHeaderIcon(boolean isWifiEnabled, WifiSliceItem wifiSliceItem) {
final Drawable drawable;
final int tint;
if (!isWifiEnabled) {
drawable = mContext.getDrawable(R.drawable.ic_wifi_off);
tint = Utils.getDisabled(mContext, Utils.getColorAttrDefaultColor(mContext,
android.R.attr.colorControlNormal));
} else {
// get icon of medium signal strength
drawable = mContext.getDrawable(com.android.settingslib.Utils.getWifiIconResource(2));
if (wifiSliceItem != null
&& wifiSliceItem.getConnectedState() == WifiEntry.CONNECTED_STATE_CONNECTED) {
tint = Utils.getColorAccentDefaultColor(mContext);
} else {
tint = Utils.getColorAttrDefaultColor(mContext, android.R.attr.colorControlNormal);
}
}
drawable.setTint(tint);
return Utils.createIconWithDrawable(drawable);
}
private CharSequence getHeaderSubtitle(WifiSliceItem wifiSliceItem) {
if (wifiSliceItem == null
|| wifiSliceItem.getConnectedState() == WifiEntry.CONNECTED_STATE_DISCONNECTED) {
return mContext.getText(R.string.disconnected);
}
if (wifiSliceItem.getConnectedState() == WifiEntry.CONNECTED_STATE_CONNECTING) {
return mContext.getString(R.string.wifi_connecting_to_message,
wifiSliceItem.getTitle());
}
return mContext.getString(R.string.wifi_connected_to_message, wifiSliceItem.getTitle());
}
private boolean hasWorkingNetwork() {
return !TextUtils.equals(getActiveSSID(), WifiManager.UNKNOWN_SSID) && hasInternetAccess();
}
private String getActiveSSID() {
if (mWifiManager.getWifiState() != WifiManager.WIFI_STATE_ENABLED) {
return WifiManager.UNKNOWN_SSID;
}
return WifiInfo.sanitizeSsid(mWifiManager.getConnectionInfo().getSSID());
}
private boolean hasInternetAccess() {
final NetworkCapabilities nc = mConnectivityManager.getNetworkCapabilities(
mWifiManager.getCurrentNetwork());
return nc != null
&& !nc.hasCapability(NetworkCapabilities.NET_CAPABILITY_CAPTIVE_PORTAL)
&& !nc.hasCapability(NetworkCapabilities.NET_CAPABILITY_PARTIAL_CONNECTIVITY)
&& nc.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED);
}
@Override
public Class getBackgroundWorkerClass() {
return ContextualWifiScanWorker.class;
}
}

7
tests/robotests/src/com/android/settings/homepage/contextualcards/ContextualCardLoaderTest.java
View File

@@ -168,6 +168,7 @@ public class ContextualCardLoaderTest {
.setName("test_dark_theme")
.setCardType(ContextualCard.CardType.SLICE)
.setSliceUri(CustomSliceRegistry.DARK_THEME_SLICE_URI)
.setCategory(STICKY_VALUE)
.build());
cards.add(new ContextualCard.Builder()
.setName("test_gesture")
@@ -175,12 +176,6 @@ public class ContextualCardLoaderTest {
.setSliceUri(Uri.parse(
"content://com.android.settings.test.slices/action/gesture_pick_up"))
.build());
cards.add(new ContextualCard.Builder()
.setName("test_wifi")
.setCardType(ContextualCard.CardType.SLICE)
.setSliceUri(CustomSliceRegistry.CONTEXTUAL_WIFI_SLICE_URI)
.setCategory(STICKY_VALUE)
.build());
cards.add(new ContextualCard.Builder()
.setName("test_connected")
.setCardType(ContextualCard.CardType.SLICE)

6
tests/robotests/src/com/android/settings/homepage/contextualcards/ContextualCardManagerTest.java
View File

@@ -234,7 +234,7 @@ public class ContextualCardManagerTest {
@Test
public void sortCards_hasStickyCards_stickyShouldAlwaysBeTheLast() {
final List<ContextualCard> cards = new ArrayList<>();
cards.add(buildContextualCard(CustomSliceRegistry.CONTEXTUAL_WIFI_SLICE_URI,
cards.add(buildContextualCard(CustomSliceRegistry.FACE_ENROLL_SLICE_URI,
ContextualCardProto.ContextualCard.Category.STICKY_VALUE, 1.02f));
cards.add(buildContextualCard(CustomSliceRegistry.BLUETOOTH_DEVICES_SLICE_URI,
ContextualCardProto.ContextualCard.Category.STICKY_VALUE, 1.01f));
@@ -246,7 +246,7 @@ public class ContextualCardManagerTest {
assertThat(sortedCards.get(cards.size() - 1).getSliceUri())
.isEqualTo(CustomSliceRegistry.BLUETOOTH_DEVICES_SLICE_URI);
assertThat(sortedCards.get(cards.size() - 2).getSliceUri())
.isEqualTo(CustomSliceRegistry.CONTEXTUAL_WIFI_SLICE_URI);
.isEqualTo(CustomSliceRegistry.FACE_ENROLL_SLICE_URI);
}
@Test
@@ -611,7 +611,7 @@ public class ContextualCardManagerTest {
@Test
public void getCardsWithViewType_hasOneStickySlice_shouldHaveOneStickyCard() {
final List<ContextualCard> cards = new ArrayList<>();
cards.add(buildContextualCard(CustomSliceRegistry.CONTEXTUAL_WIFI_SLICE_URI.toString()));
cards.add(buildContextualCard(CustomSliceRegistry.FACE_ENROLL_SLICE_URI.toString()));
cards.add(buildContextualCard(CustomSliceRegistry.LOW_STORAGE_SLICE_URI.toString()));
final List<Integer> categories = Arrays.asList(
ContextualCardProto.ContextualCard.Category.STICKY_VALUE,

10
tests/robotests/src/com/android/settings/homepage/contextualcards/SettingsContextualCardProviderTest.java
View File

@@ -70,16 +70,16 @@ public class SettingsContextualCardProviderTest {
}
@Test
public void getContextualCards_wifiSlice_shouldGetImportantCategory() {
public void getContextualCards_darkThemeSlice_shouldGetImportantCategory() {
final ContextualCardList cards = mProvider.getContextualCards();
ContextualCard wifiCard = null;
ContextualCard darkThemeCard = null;
for (ContextualCard card : cards.getCardList()) {
if (card.getSliceUri().equals(
CustomSliceRegistry.CONTEXTUAL_WIFI_SLICE_URI.toString())) {
wifiCard = card;
CustomSliceRegistry.DARK_THEME_SLICE_URI.toString())) {
darkThemeCard = card;
}
}
assertThat(wifiCard.getCardCategory()).isEqualTo(ContextualCard.Category.IMPORTANT);
assertThat(darkThemeCard.getCardCategory()).isEqualTo(ContextualCard.Category.IMPORTANT);
}
}

6
tests/robotests/src/com/android/settings/homepage/contextualcards/slices/SliceContextualCardRendererTest.java
View File

@@ -38,18 +38,16 @@ import androidx.lifecycle.LifecycleOwner;
import androidx.lifecycle.LiveData;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import androidx.slice.builders.ListBuilder;
import androidx.slice.builders.SliceAction;
import androidx.slice.Slice;
import androidx.slice.SliceProvider;
import androidx.slice.builders.ListBuilder;
import androidx.slice.builders.SliceAction;
import androidx.slice.widget.SliceLiveData;
import com.android.settings.R;
import com.android.settings.homepage.contextualcards.ContextualCard;
import com.android.settings.homepage.contextualcards.ContextualCardsFragment;
import com.android.settings.homepage.contextualcards.ControllerRendererPool;
import com.android.settings.wifi.slice.ContextualWifiSlice;
import org.junit.Before;
import org.junit.Test;

190
tests/robotests/src/com/android/settings/wifi/slice/ContextualWifiSliceTest.java
View File

@@ -1,190 +0,0 @@
/*
* Copyright (C) 2018 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.settings.wifi.slice;
import static com.android.settings.wifi.slice.ContextualWifiSlice.COLLAPSED_ROW_COUNT;
import static com.android.settings.wifi.slice.WifiSlice.DEFAULT_EXPANDED_ROW_COUNT;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;
import android.content.ContentResolver;
import android.content.Context;
import android.content.pm.PackageManager;
import android.net.Network;
import android.net.NetworkCapabilities;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import androidx.core.graphics.drawable.IconCompat;
import androidx.slice.Slice;
import androidx.slice.SliceMetadata;
import androidx.slice.SliceProvider;
import androidx.slice.core.SliceAction;
import androidx.slice.widget.SliceLiveData;
import com.android.settings.R;
import com.android.settings.slices.CustomSliceRegistry;
import com.android.settings.slices.SlicesFeatureProviderImpl;
import com.android.settings.testutils.FakeFeatureFactory;
import com.android.settings.testutils.shadow.ShadowConnectivityManager;
import com.android.settings.testutils.shadow.ShadowWifiSlice;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
import org.robolectric.shadows.ShadowBinder;
import java.util.List;
@RunWith(RobolectricTestRunner.class)
@Config(shadows = {ShadowConnectivityManager.class, ShadowWifiSlice.class})
public class ContextualWifiSliceTest {
private static final String SSID = "123";
@Mock
private WifiManager mWifiManager;
@Mock
private PackageManager mPackageManager;
@Mock
private WifiInfo mWifiInfo;
@Mock
private Network mNetwork;
private Context mContext;
private ContentResolver mResolver;
private ContextualWifiSlice mWifiSlice;
private FakeFeatureFactory mFeatureFactory;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mContext = spy(RuntimeEnvironment.application);
mResolver = mock(ContentResolver.class);
mFeatureFactory = FakeFeatureFactory.setupForTest();
mFeatureFactory.slicesFeatureProvider = new SlicesFeatureProviderImpl();
mFeatureFactory.slicesFeatureProvider.newUiSession();
doReturn(mResolver).when(mContext).getContentResolver();
doReturn(mWifiManager).when(mContext).getSystemService(WifiManager.class);
doReturn(true).when(mWifiManager).isWifiEnabled();
doReturn(WifiManager.WIFI_STATE_ENABLED).when(mWifiManager).getWifiState();
doReturn(mWifiInfo).when(mWifiManager).getConnectionInfo();
doReturn(SSID).when(mWifiInfo).getSSID();
doReturn(mNetwork).when(mWifiManager).getCurrentNetwork();
when(mContext.getPackageManager()).thenReturn(mPackageManager);
// Set-up specs for SliceMetadata.
SliceProvider.setSpecs(SliceLiveData.SUPPORTED_SPECS);
final String siPackageName =
mContext.getString(R.string.config_settingsintelligence_package_name);
ShadowBinder.setCallingUid(1);
when(mPackageManager.getPackagesForUid(1)).thenReturn(new String[]{siPackageName});
when(mPackageManager.getNameForUid(1)).thenReturn(siPackageName);
ShadowWifiSlice.setWifiPermissible(true);
mWifiSlice = new ContextualWifiSlice(mContext);
}
@Test
public void getWifiSlice_newSession_hasActiveConnection_shouldCollapseSlice() {
mWifiSlice.sActiveUiSession = ~mFeatureFactory.slicesFeatureProvider.getUiSessionToken();
connectToWifi(makeValidatedNetworkCapabilities());
final Slice wifiSlice = mWifiSlice.getSlice();
assertWifiHeader(wifiSlice);
assertThat(ContextualWifiSlice.getApRowCount()).isEqualTo(COLLAPSED_ROW_COUNT);
}
@Test
public void getWifiSlice_newSession_noConnection_shouldExpandSlice() {
mWifiSlice.sActiveUiSession = ~mFeatureFactory.slicesFeatureProvider.getUiSessionToken();
final Slice wifiSlice = mWifiSlice.getSlice();
assertWifiHeader(wifiSlice);
assertThat(ContextualWifiSlice.getApRowCount()).isEqualTo(DEFAULT_EXPANDED_ROW_COUNT);
}
@Test
public void getWifiSlice_previousExpanded_hasActiveConnection_shouldExpandSlice() {
mWifiSlice.sActiveUiSession = mFeatureFactory.slicesFeatureProvider.getUiSessionToken();
mWifiSlice.sApRowCollapsed = false;
connectToWifi(makeValidatedNetworkCapabilities());
final Slice wifiSlice = mWifiSlice.getSlice();
assertWifiHeader(wifiSlice);
assertThat(ContextualWifiSlice.getApRowCount()).isEqualTo(DEFAULT_EXPANDED_ROW_COUNT);
}
@Test
public void getWifiSlice_previousCollapsed_connectionLoss_shouldCollapseSlice() {
mWifiSlice.sActiveUiSession = mFeatureFactory.slicesFeatureProvider.getUiSessionToken();
mWifiSlice.sApRowCollapsed = true;
connectToWifi(makeValidatedNetworkCapabilities());
doReturn(null).when(mWifiManager).getCurrentNetwork();
final Slice wifiSlice = mWifiSlice.getSlice();
assertWifiHeader(wifiSlice);
assertThat(ContextualWifiSlice.getApRowCount()).isEqualTo(COLLAPSED_ROW_COUNT);
}
@Test
public void getWifiSlice_contextualWifiSlice_shouldReturnContextualWifiSliceUri() {
mWifiSlice.sActiveUiSession = mFeatureFactory.slicesFeatureProvider.getUiSessionToken();
final Slice wifiSlice = mWifiSlice.getSlice();
assertThat(wifiSlice.getUri()).isEqualTo(CustomSliceRegistry.CONTEXTUAL_WIFI_SLICE_URI);
}
private void connectToWifi(NetworkCapabilities nc) {
ShadowConnectivityManager.getShadow().setNetworkCapabilities(mNetwork, nc);
}
private NetworkCapabilities makeValidatedNetworkCapabilities() {
final NetworkCapabilities nc = NetworkCapabilities.Builder.withoutDefaultCapabilities()
.addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
.addCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
.build();
return nc;
}
private void assertWifiHeader(Slice slice) {
final SliceMetadata metadata = SliceMetadata.from(mContext, slice);
assertThat(metadata.getTitle()).isEqualTo(mContext.getString(R.string.wifi_settings));
final SliceAction primaryAction = metadata.getPrimaryAction();
final IconCompat expectedToggleIcon = IconCompat.createWithResource(mContext,
R.drawable.ic_settings_wireless);
assertThat(primaryAction.getIcon().toString()).isEqualTo(expectedToggleIcon.toString());
final List<SliceAction> toggles = metadata.getToggles();
assertThat(toggles).hasSize(1);
}
}