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

[Wi-Fi] Replace WifiTracker with WifiPickerTracker in WifiSettings

Browse Source 
WifiSettings uses WifiTracker in SettingsLib while WifiSettings2
uses WifiPickerTracker in WifiSettingsLib.

1. Remove WifiSettings.
2. Rename WifiSettings2 to WifiSettings.
3. Remove the files only used in the removed WifiSettings.
   (Saved networks files are not included)

Bug: 152571756
Test: make RunSettingsRoboTests -j ROBOTEST_FILTER=com.android.settings.wifi
      atest WifiSettingsUiTest
Change-Id: I800b434c8049121db115cff87d51e164e4529999
This commit is contained in:
Arc Wang
2020-05-11 21:30:42 +08:00
parent 29d45e2d6b
commit 41f23de712
20 changed files with 737 additions and 3265 deletions
Download Patch File Download Diff File Expand all files Collapse all files

189
tests/unit/src/com/android/settings/wifi/WifiSettingsUiTest.java
View File

@@ -15,31 +15,27 @@
*/
package com.android.settings.wifi;
import static androidx.test.InstrumentationRegistry.getInstrumentation;
import static androidx.test.espresso.Espresso.onView;
import static androidx.test.espresso.assertion.ViewAssertions.doesNotExist;
import static androidx.test.espresso.assertion.ViewAssertions.matches;
import static androidx.test.espresso.matcher.ViewMatchers.Visibility.VISIBLE;
import static androidx.test.espresso.matcher.ViewMatchers.isDisplayed;
import static androidx.test.espresso.matcher.ViewMatchers.withEffectiveVisibility;
import static androidx.test.espresso.matcher.ViewMatchers.withId;
import static androidx.test.espresso.matcher.ViewMatchers.withText;
import static com.google.common.truth.Truth.assertThat;
import static org.hamcrest.Matchers.allOf;
import static org.hamcrest.Matchers.startsWith;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import android.content.Context;
import android.content.Intent;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiConfiguration.NetworkSelectionStatus;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.provider.Settings;
import android.support.test.uiautomator.UiDevice;
import androidx.fragment.app.Fragment;
import androidx.test.InstrumentationRegistry;
@@ -48,11 +44,8 @@ import androidx.test.runner.AndroidJUnit4;
import com.android.settings.Settings.WifiSettingsActivity;
import com.android.settingslib.utils.ThreadUtils;
import com.android.settingslib.wifi.AccessPoint;
import com.android.settingslib.wifi.TestAccessPointBuilder;
import com.android.settingslib.wifi.WifiTracker;
import com.android.settingslib.wifi.WifiTracker.WifiListener;
import com.android.settingslib.wifi.WifiTrackerFactory;
import com.android.wifitrackerlib.WifiEntry;
import com.android.wifitrackerlib.WifiPickerTracker;
import com.google.common.collect.Lists;
@@ -63,36 +56,28 @@ import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import java.nio.charset.StandardCharsets;
import java.util.List;
@RunWith(AndroidJUnit4.class)
public class WifiSettingsUiTest {
private static final String TEST_SSID = "\"Test Ssid\"";
private static final String TEST_UNQUOTED_SSID = "Test Ssid";
private static final String TEST_BSSID = "0a:08:5c:67:89:00";
private static final int TEST_RSSI = 123;
private static final int TEST_NETWORK_ID = 1;
private static final String TEST_SSID = "Test Ssid";
private static final String TEST_KEY = "Test Key";
// Keys used to lookup resources by name (see the resourceId/resourceString helper methods).
private static final String ID = "id";
private static final String STRING = "string";
private static final String WIFI_CONFIGURE_SETTINGS_PREFERENCE_TITLE =
"wifi_configure_settings_preference_title";
private static final String WIFI_SAVED_ACCESS_POINTS_LABEL = "wifi_saved_access_points_label";
private static final String WIFI_EMPTY_LIST_WIFI_OFF = "wifi_empty_list_wifi_off";
private static final String WIFI_DISPLAY_STATUS_CONNECTED = "wifi_display_status_connected";
private static final String WIFI_PASSWORD = "wifi_password";
private static final String WIFI_SHOW_PASSWORD = "wifi_show_password";
private static final String PASSWORD_LAYOUT = "password_layout";
private static final String PASSWORD = "password";
@Mock
private WifiTracker mWifiTracker;
private WifiPickerTracker mWifiTracker;
@Mock
private WifiManager mWifiManager;
private WifiPickerTracker.WifiPickerTrackerCallback mWifiListener;
private Context mContext;
private WifiListener mWifiListener;
private UiDevice mDevice;
@Rule
public ActivityTestRule<WifiSettingsActivity> mActivityRule =
@@ -102,8 +87,7 @@ public class WifiSettingsUiTest {
public void setUp() {
MockitoAnnotations.initMocks(this);
mContext = InstrumentationRegistry.getTargetContext();
WifiTrackerFactory.setTestingWifiTracker(mWifiTracker);
when(mWifiTracker.getManager()).thenReturn(mWifiManager);
mDevice = UiDevice.getInstance(getInstrumentation());
}
/**
@@ -121,33 +105,6 @@ public class WifiSettingsUiTest {
return mContext.getResources().getString(resourceId(STRING, name));
}
private void setupConnectedAccessPoint() {
WifiConfiguration config = new WifiConfiguration();
config.SSID = TEST_SSID;
config.BSSID = TEST_BSSID;
config.networkId = TEST_NETWORK_ID;
WifiInfo wifiInfo = new WifiInfo.Builder()
.setSsid(TEST_UNQUOTED_SSID.getBytes(StandardCharsets.UTF_8))
.setBssid(TEST_BSSID)
.setRssi(TEST_RSSI)
.setNetworkId(TEST_NETWORK_ID)
.build();
NetworkInfo networkInfo = new NetworkInfo(ConnectivityManager.TYPE_WIFI, 0, null, null);
networkInfo.setDetailedState(NetworkInfo.DetailedState.CONNECTED, null, null);
AccessPoint accessPoint = new AccessPoint(mContext, config);
accessPoint.update(config, wifiInfo, networkInfo);
assertThat(accessPoint.getSsidStr()).isEqualTo(TEST_UNQUOTED_SSID);
assertThat(accessPoint.getBssid()).isEqualTo(TEST_BSSID);
assertThat(accessPoint.getNetworkInfo()).isNotNull();
assertThat(accessPoint.isActive()).isTrue();
assertThat(accessPoint.getSettingsSummary()).isEqualTo(
resourceString(WIFI_DISPLAY_STATUS_CONNECTED));
when(mWifiTracker.getAccessPoints()).thenReturn(
Lists.asList(accessPoint, new AccessPoint[] {}));
}
/** Launch the activity via an Intent with a String extra. */
private void launchActivity(String extraName, String extraValue) {
Intent intent = new Intent(Settings.ACTION_WIFI_SETTINGS);
@@ -156,11 +113,10 @@ public class WifiSettingsUiTest {
}
mActivityRule.launchActivity(intent);
verify(mWifiTracker).getManager();
List<Fragment> fragments =
mActivityRule.getActivity().getSupportFragmentManager().getFragments();
assertThat(fragments.size()).isEqualTo(1);
((WifiSettings) fragments.get(0)).mWifiPickerTracker = mWifiTracker;
mWifiListener = (WifiSettings) fragments.get(0);
assertThat(mWifiListener).isNotNull();
}
@@ -171,13 +127,7 @@ public class WifiSettingsUiTest {
}
private void setWifiState(int wifiState) {
when(mWifiManager.getWifiState()).thenReturn(wifiState);
when(mWifiManager.isWifiEnabled()).thenReturn(wifiState == WifiManager.WIFI_STATE_ENABLED);
}
private void callOnWifiStateChanged(int state) {
mActivityRule.getActivity().getMainThreadHandler()
.post(() -> mWifiListener.onWifiStateChanged(state));
when(mWifiTracker.getWifiState()).thenReturn(wifiState);
}
@Test
@@ -210,28 +160,32 @@ public class WifiSettingsUiTest {
when(mWifiTracker.getNumSavedNetworks()).thenReturn(1);
launchActivity();
mActivityRule.getActivity().getMainThreadHandler()
.post(() -> mWifiListener.onNumSavedNetworksChanged());
onView(allOf(withText(resourceId(STRING, WIFI_SAVED_ACCESS_POINTS_LABEL)),
withEffectiveVisibility(VISIBLE))).check(matches(isDisplayed()));
}
@Test
public void onDisableWifi_seeOffMessage() {
public void onWifiStateChanged_wifiDisabled_seeOffMessage() {
setWifiState(WifiManager.WIFI_STATE_DISABLED);
launchActivity();
callOnWifiStateChanged(WifiManager.WIFI_STATE_DISABLED);
mActivityRule.getActivity().getMainThreadHandler()
.post(() -> mWifiListener.onWifiStateChanged());
onView(withText(startsWith(resourceString(WIFI_EMPTY_LIST_WIFI_OFF)))).check(
matches(isDisplayed()));
}
@Test
public void onEnableWifi_shouldNotSeeOffMessage() {
public void onWifiStateChanged_wifiEnabled_shouldNotSeeOffMessage() {
setWifiState(WifiManager.WIFI_STATE_ENABLED);
launchActivity();
callOnWifiStateChanged(WifiManager.WIFI_STATE_ENABLED);
mActivityRule.getActivity().getMainThreadHandler()
.post(() -> mWifiListener.onWifiStateChanged());
onView(withText(startsWith(resourceString(WIFI_EMPTY_LIST_WIFI_OFF)))).check(
doesNotExist());
@@ -240,94 +194,55 @@ public class WifiSettingsUiTest {
@Test
public void onConnected_shouldSeeConnectedMessage() {
setWifiState(WifiManager.WIFI_STATE_ENABLED);
setupConnectedAccessPoint();
when(mWifiTracker.isConnected()).thenReturn(true);
final WifiEntry wifiEntry = mock(WifiEntry.class);
when(wifiEntry.getConnectedState()).thenReturn(WifiEntry.CONNECTED_STATE_CONNECTED);
when(wifiEntry.getSummary(false /* concise */))
.thenReturn(resourceString(WIFI_DISPLAY_STATUS_CONNECTED));
when(wifiEntry.getKey()).thenReturn(TEST_KEY);
when(mWifiTracker.getConnectedWifiEntry()).thenReturn(wifiEntry);
launchActivity();
ThreadUtils.postOnMainThread(() -> mWifiListener.onWifiEntriesChanged());
mDevice.waitForIdle();
onView(withText(resourceString(WIFI_DISPLAY_STATUS_CONNECTED))).check(
matches(isDisplayed()));
}
@Test
public void changingSecurityStateOnApShouldNotCauseMultipleListItems() {
public void changingSecurityStateOnAp_ShouldNotCauseMultipleListItems() {
setWifiState(WifiManager.WIFI_STATE_ENABLED);
TestAccessPointBuilder builder = new TestAccessPointBuilder(mContext)
.setSsid(TEST_SSID)
.setSecurity(AccessPoint.SECURITY_NONE)
.setRssi(TEST_RSSI);
AccessPoint open = builder.build();
builder.setSecurity(AccessPoint.SECURITY_EAP);
AccessPoint eap = builder.build();
final WifiEntry openWifiEntry = mock(WifiEntry.class);
when(openWifiEntry.getTitle()).thenReturn(TEST_SSID);
when(openWifiEntry.getSecurity()).thenReturn(WifiEntry.SECURITY_NONE);
builder.setSecurity(AccessPoint.SECURITY_WEP);
AccessPoint wep = builder.build();
final WifiEntry eapWifiEntry = mock(WifiEntry.class);
when(eapWifiEntry.getTitle()).thenReturn(TEST_SSID);
when(eapWifiEntry.getSecurity()).thenReturn(WifiEntry.SECURITY_EAP);
// Return a different security state each time getAccessPoints is invoked
when(mWifiTracker.getAccessPoints())
.thenReturn(Lists.newArrayList(open))
.thenReturn(Lists.newArrayList(eap))
.thenReturn(Lists.newArrayList(wep));
final WifiEntry wepWifiEntry = mock(WifiEntry.class);
when(wepWifiEntry.getTitle()).thenReturn(TEST_SSID);
when(wepWifiEntry.getSecurity()).thenReturn(WifiEntry.SECURITY_WEP);
// Return a different security state each time getWifiEntries is invoked
when(mWifiTracker.getWifiEntries())
.thenReturn(Lists.newArrayList(openWifiEntry))
.thenReturn(Lists.newArrayList(eapWifiEntry))
.thenReturn(Lists.newArrayList(wepWifiEntry));
launchActivity();
ThreadUtils.postOnMainThread(() -> mWifiListener.onWifiEntriesChanged());
mDevice.waitForIdle();
onView(withText(TEST_SSID)).check(matches(isDisplayed()));
ThreadUtils.postOnMainThread(() -> mWifiListener.onAccessPointsChanged());
ThreadUtils.postOnMainThread(() -> mWifiListener.onWifiEntriesChanged());
mDevice.waitForIdle();
onView(withText(TEST_SSID)).check(matches(isDisplayed()));
ThreadUtils.postOnMainThread(() -> mWifiListener.onAccessPointsChanged());
ThreadUtils.postOnMainThread(() -> mWifiListener.onWifiEntriesChanged());
mDevice.waitForIdle();
onView(withText(TEST_SSID)).check(matches(isDisplayed()));
}
@Test
public void wrongPasswordSavedNetwork() {
setWifiState(WifiManager.WIFI_STATE_ENABLED);
// Set up an AccessPoint that is disabled due to incorrect password.
WifiConfiguration config = new WifiConfiguration();
config.SSID = TEST_SSID;
config.BSSID = TEST_BSSID;
config.networkId = TEST_NETWORK_ID;
config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
NetworkSelectionStatus selectionStatus = new NetworkSelectionStatus.Builder()
.setNetworkSelectionDisableReason(
NetworkSelectionStatus.DISABLED_BY_WRONG_PASSWORD)
.setNetworkSelectionStatus(
NetworkSelectionStatus.NETWORK_SELECTION_TEMPORARY_DISABLED)
.build();
config.setNetworkSelectionStatus(selectionStatus);
WifiInfo wifiInfo = new WifiInfo.Builder()
.setSsid(TEST_UNQUOTED_SSID.getBytes(StandardCharsets.UTF_8))
.setBssid(TEST_BSSID)
.setRssi(TEST_RSSI)
.setNetworkId(TEST_NETWORK_ID)
.build();
AccessPoint accessPoint = new AccessPoint(mContext, config);
accessPoint.update(config, wifiInfo, null);
// Make sure we've set up our access point correctly.
assertThat(accessPoint.getSsidStr()).isEqualTo(TEST_UNQUOTED_SSID);
assertThat(accessPoint.getBssid()).isEqualTo(TEST_BSSID);
assertThat(accessPoint.isActive()).isFalse();
assertThat(accessPoint.getConfig()).isNotNull();
NetworkSelectionStatus networkStatus = accessPoint.getConfig().getNetworkSelectionStatus();
assertThat(networkStatus).isNotNull();
assertThat(networkStatus.getNetworkSelectionStatus())
.isEqualTo(NetworkSelectionStatus.NETWORK_SELECTION_TEMPORARY_DISABLED);
assertThat(networkStatus.getNetworkSelectionDisableReason()).isEqualTo(
NetworkSelectionStatus.DISABLED_BY_WRONG_PASSWORD);
when(mWifiTracker.getAccessPoints()).thenReturn(Lists.newArrayList(accessPoint));
launchActivity(WifiSettings.EXTRA_START_CONNECT_SSID, accessPoint.getSsidStr());
// Make sure that the password dialog is visible.
onView(withText(resourceId(STRING, WIFI_PASSWORD))).check(matches(isDisplayed()));
onView(withText(resourceId(STRING, WIFI_SHOW_PASSWORD))).check(matches(isDisplayed()));
onView(withId(resourceId(ID, PASSWORD_LAYOUT))).check(matches(isDisplayed()));
onView(withId(resourceId(ID, PASSWORD))).check(matches(isDisplayed()));
}
}