From e46081819d4cd9893ae08d990c0c21d08012cd12 Mon Sep 17 00:00:00 2001 From: Arc Wang Date: Thu, 7 May 2020 10:41:54 +0800 Subject: [PATCH] [Wi-Fi] Apply WifiTrackerLib objects in wifi/dpp/WifiNetworkListFragment Bug: 152571756 Bug: 145100890 Test: make RunSettingsRoboTests ROBOTEST_FILTER=WifiNetworkListFragmentTest Change-Id: I2136b452da4a3008f493c46c8ed14b311cfc9fdd --- .../wifi/dpp/WifiDppConfiguratorActivity.java | 9 - .../settings/wifi/dpp/WifiDppUtils.java | 4 - .../settings/wifi/dpp/WifiNetworkConfig.java | 6 + .../wifi/dpp/WifiNetworkListFragment.java | 301 +++++++----------- .../wifi/dpp/WifiNetworkListFragmentTest.java | 142 +++++++++ .../wifi/dpp/WifiNetworkListFragmentTest.java | 169 ---------- 6 files changed, 256 insertions(+), 375 deletions(-) create mode 100644 tests/robotests/src/com/android/settings/wifi/dpp/WifiNetworkListFragmentTest.java delete mode 100644 tests/unit/src/com/android/settings/wifi/dpp/WifiNetworkListFragmentTest.java diff --git a/src/com/android/settings/wifi/dpp/WifiDppConfiguratorActivity.java b/src/com/android/settings/wifi/dpp/WifiDppConfiguratorActivity.java index b19e3b8c4c9..6659c7ace91 100644 --- a/src/com/android/settings/wifi/dpp/WifiDppConfiguratorActivity.java +++ b/src/com/android/settings/wifi/dpp/WifiDppConfiguratorActivity.java @@ -88,9 +88,6 @@ public class WifiDppConfiguratorActivity extends WifiDppBaseActivity implements */ private int[] mWifiDppRemoteBandSupport; - /** Secret extra that allows fake networks to show in UI for testing purposes */ - private boolean mIsTest; - @Override public int getMetricsCategory() { return SettingsEnums.SETTINGS_WIFI_DPP_CONFIGURATOR; @@ -149,7 +146,6 @@ public class WifiDppConfiguratorActivity extends WifiDppBaseActivity implements case Settings.ACTION_PROCESS_WIFI_EASY_CONNECT_URI: final Uri uri = intent.getData(); final String uriString = (uri == null) ? null : uri.toString(); - mIsTest = intent.getBooleanExtra(WifiDppUtils.EXTRA_TEST, false); mWifiDppQrCode = WifiQrCode.getValidWifiDppQrCodeOrNull(uriString); mWifiDppRemoteBandSupport = intent.getIntArrayExtra( Settings.EXTRA_EASY_CONNECT_BAND_LIST); // returns null if none @@ -239,11 +235,6 @@ public class WifiDppConfiguratorActivity extends WifiDppBaseActivity implements if (fragment == null) { fragment = new WifiDppChooseSavedWifiNetworkFragment(); - if (mIsTest) { - Bundle bundle = new Bundle(); - bundle.putBoolean(WifiDppUtils.EXTRA_TEST, true); - fragment.setArguments(bundle); - } } else { if (fragment.isVisible()) { return; diff --git a/src/com/android/settings/wifi/dpp/WifiDppUtils.java b/src/com/android/settings/wifi/dpp/WifiDppUtils.java index 7a502c93304..9ad59be6db1 100644 --- a/src/com/android/settings/wifi/dpp/WifiDppUtils.java +++ b/src/com/android/settings/wifi/dpp/WifiDppUtils.java @@ -83,10 +83,6 @@ public class WifiDppUtils { /** The data to recognize if it's a Wi-Fi hotspot for configuration */ static final String EXTRA_IS_HOTSPOT = "isHotspot"; - /** Used by {@link android.provider.Settings#ACTION_PROCESS_WIFI_EASY_CONNECT_URI} to - * indicate test mode UI should be shown. Test UI does not make API calls. Value is a boolean.*/ - static final String EXTRA_TEST = "test"; - /** * Default status code for Easy Connect */ diff --git a/src/com/android/settings/wifi/dpp/WifiNetworkConfig.java b/src/com/android/settings/wifi/dpp/WifiNetworkConfig.java index e6195d19e16..605879df445 100644 --- a/src/com/android/settings/wifi/dpp/WifiNetworkConfig.java +++ b/src/com/android/settings/wifi/dpp/WifiNetworkConfig.java @@ -48,6 +48,9 @@ public class WifiNetworkConfig { static final String FAKE_PASSWORD = "password"; private static final String TAG = "WifiNetworkConfig"; + // Security from WifiNetworkListFragment/WifiTrackerLib may be WPA3. + static final String SECURITY_WPA3 = "WPA3"; + private String mSecurity; private String mSsid; private String mPreSharedKey; @@ -59,6 +62,9 @@ public class WifiNetworkConfig { WifiNetworkConfig(String security, String ssid, String preSharedKey, boolean hiddenSsid, int networkId, boolean isHotspot) { mSecurity = security; + if (TextUtils.equals(mSecurity, SECURITY_WPA3)) { + mSecurity = SECURITY_SAE; + } mSsid = ssid; mPreSharedKey = preSharedKey; mHiddenSsid = hiddenSsid; diff --git a/src/com/android/settings/wifi/dpp/WifiNetworkListFragment.java b/src/com/android/settings/wifi/dpp/WifiNetworkListFragment.java index c8548288475..57b1feb18e2 100644 --- a/src/com/android/settings/wifi/dpp/WifiNetworkListFragment.java +++ b/src/com/android/settings/wifi/dpp/WifiNetworkListFragment.java @@ -20,13 +20,20 @@ import android.app.Activity; import android.app.settings.SettingsEnums; import android.content.Context; import android.content.Intent; +import android.net.ConnectivityManager; +import android.net.NetworkScoreManager; import android.net.wifi.WifiConfiguration; import android.net.wifi.WifiManager; import android.os.Bundle; -import android.util.Log; -import android.view.View; +import android.os.Handler; +import android.os.HandlerThread; +import android.os.Looper; +import android.os.Process; +import android.os.SimpleClock; +import android.os.SystemClock; import android.widget.Toast; +import androidx.annotation.VisibleForTesting; import androidx.preference.Preference; import androidx.preference.PreferenceCategory; @@ -34,47 +41,63 @@ import com.android.settings.R; import com.android.settings.SettingsPreferenceFragment; import com.android.settings.core.SubSettingLauncher; import com.android.settings.wifi.AddNetworkFragment; -import com.android.settingslib.wifi.AccessPoint; -import com.android.settingslib.wifi.AccessPointPreference; -import com.android.settingslib.wifi.WifiSavedConfigUtils; -import com.android.settingslib.wifi.WifiTracker; -import com.android.settingslib.wifi.WifiTrackerFactory; +import com.android.settingslib.wifi.WifiEntryPreference; +import com.android.wifitrackerlib.SavedNetworkTracker; +import com.android.wifitrackerlib.WifiEntry; +import java.time.Clock; +import java.time.ZoneOffset; import java.util.List; import java.util.stream.Collectors; public class WifiNetworkListFragment extends SettingsPreferenceFragment implements - WifiTracker.WifiListener, AccessPoint.AccessPointListener { + SavedNetworkTracker.SavedNetworkTrackerCallback, Preference.OnPreferenceClickListener { private static final String TAG = "WifiNetworkListFragment"; - private static final String WIFI_CONFIG_KEY = "wifi_config_key"; + @VisibleForTesting static final String WIFI_CONFIG_KEY = "wifi_config_key"; private static final String PREF_KEY_ACCESS_POINTS = "access_points"; - private static final int ADD_NETWORK_REQUEST = 1; + @VisibleForTesting + static final int ADD_NETWORK_REQUEST = 1; - private PreferenceCategory mAccessPointsPreferenceCategory; - private AccessPointPreference.UserBadgeCache mUserBadgeCache; - private Preference mAddPreference; - // Only shows up if mIsTest == true - private Preference mFakeNetworkPreference; + @VisibleForTesting PreferenceCategory mPreferenceGroup; + @VisibleForTesting Preference mAddPreference; - private WifiManager mWifiManager; - private WifiTracker mWifiTracker; + @VisibleForTesting WifiManager mWifiManager; private WifiManager.ActionListener mSaveListener; - private boolean mIsTest; + + // Max age of tracked WifiEntries + private static final long MAX_SCAN_AGE_MILLIS = 15_000; + // Interval between initiating SavedNetworkTracker scans + private static final long SCAN_INTERVAL_MILLIS = 10_000; + + @VisibleForTesting SavedNetworkTracker mSavedNetworkTracker; + private HandlerThread mWorkerThread; // Container Activity must implement this interface public interface OnChooseNetworkListener { void onChooseNetwork(WifiNetworkConfig wifiNetworkConfig); } - private OnChooseNetworkListener mOnChooseNetworkListener; + @VisibleForTesting OnChooseNetworkListener mOnChooseNetworkListener; @Override public int getMetricsCategory() { return SettingsEnums.SETTINGS_WIFI_DPP_CONFIGURATOR; } + private static class DisableUnreachableWifiEntryPreference extends WifiEntryPreference { + DisableUnreachableWifiEntryPreference(Context context, WifiEntry entry) { + super(context, entry); + } + + @Override + public void onUpdated() { + super.onUpdated(); + this.setEnabled(getWifiEntry().getLevel() != WifiEntry.WIFI_LEVEL_UNREACHABLE); + } + } + @Override public void onAttach(Context context) { super.onAttach(context); @@ -94,14 +117,8 @@ public class WifiNetworkListFragment extends SettingsPreferenceFragment implemen public void onActivityCreated(Bundle savedInstanceState) { super.onActivityCreated(savedInstanceState); - mWifiTracker = WifiTrackerFactory.create(getActivity(), this, - getSettingsLifecycle(), /* includeSaved */true, /* includeScans */ true); - mWifiManager = mWifiTracker.getManager(); - - final Bundle args = getArguments(); - if (args != null) { - mIsTest = args.getBoolean(WifiDppUtils.EXTRA_TEST, false); - } + final Context context = getContext(); + mWifiManager = context.getSystemService(WifiManager.class); mSaveListener = new WifiManager.ActionListener() { @Override @@ -111,25 +128,45 @@ public class WifiNetworkListFragment extends SettingsPreferenceFragment implemen @Override public void onFailure(int reason) { - Activity activity = getActivity(); - if (activity != null) { - Toast.makeText(activity, - R.string.wifi_failed_save_message, + final Activity activity = getActivity(); + if (activity != null && !activity.isFinishing()) { + Toast.makeText(activity, R.string.wifi_failed_save_message, Toast.LENGTH_SHORT).show(); } } }; + + mWorkerThread = new HandlerThread(TAG + + "{" + Integer.toHexString(System.identityHashCode(this)) + "}", + Process.THREAD_PRIORITY_BACKGROUND); + mWorkerThread.start(); + final Clock elapsedRealtimeClock = new SimpleClock(ZoneOffset.UTC) { + @Override + public long millis() { + return SystemClock.elapsedRealtime(); + } + }; + mSavedNetworkTracker = new SavedNetworkTracker(getSettingsLifecycle(), context, + context.getSystemService(WifiManager.class), + context.getSystemService(ConnectivityManager.class), + context.getSystemService(NetworkScoreManager.class), + new Handler(Looper.getMainLooper()), + mWorkerThread.getThreadHandler(), + elapsedRealtimeClock, + MAX_SCAN_AGE_MILLIS, + SCAN_INTERVAL_MILLIS, + this); } @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { super.onActivityResult(requestCode, resultCode, data); - if (requestCode == ADD_NETWORK_REQUEST) { - if (resultCode == Activity.RESULT_OK) { - handleAddNetworkSubmitEvent(data); + if (requestCode == ADD_NETWORK_REQUEST && resultCode == Activity.RESULT_OK) { + final WifiConfiguration wifiConfiguration = data.getParcelableExtra(WIFI_CONFIG_KEY); + if (wifiConfiguration != null) { + mWifiManager.save(wifiConfiguration, mSaveListener); } - mWifiTracker.resumeScanning(); } } @@ -137,203 +174,81 @@ public class WifiNetworkListFragment extends SettingsPreferenceFragment implemen public void onCreatePreferences(Bundle savedInstanceState, String rootKey) { addPreferencesFromResource(R.xml.wifi_dpp_network_list); - mAccessPointsPreferenceCategory = findPreference(PREF_KEY_ACCESS_POINTS); - - mFakeNetworkPreference = new Preference(getPrefContext()); - mFakeNetworkPreference.setIcon(R.drawable.ic_wifi_signal_0); - mFakeNetworkPreference.setKey("fake_key"); - mFakeNetworkPreference.setTitle("fake network"); + mPreferenceGroup = findPreference(PREF_KEY_ACCESS_POINTS); mAddPreference = new Preference(getPrefContext()); mAddPreference.setIcon(R.drawable.ic_add_24dp); mAddPreference.setTitle(R.string.wifi_add_network); - - mUserBadgeCache = new AccessPointPreference.UserBadgeCache(getPackageManager()); + mAddPreference.setOnPreferenceClickListener(this); } /** Called when the state of Wifi has changed. */ @Override - public void onWifiStateChanged(int state) { - final int wifiState = mWifiManager.getWifiState(); - switch (wifiState) { - case WifiManager.WIFI_STATE_ENABLED: - updateAccessPointPreferences(); - break; + public void onSavedWifiEntriesChanged() { + final List savedWifiEntries = mSavedNetworkTracker.getSavedWifiEntries().stream() + .filter(entry -> isValidForDppConfiguration(entry)) + .collect(Collectors.toList()); - case WifiManager.WIFI_STATE_ENABLING: - case WifiManager.WIFI_STATE_DISABLING: - removeAccessPointPreferences(); - break; + int index = 0; + mPreferenceGroup.removeAll(); + for (WifiEntry savedEntry : savedWifiEntries) { + final DisableUnreachableWifiEntryPreference preference = + new DisableUnreachableWifiEntryPreference(getContext(), savedEntry); + preference.setOnPreferenceClickListener(this); + preference.setEnabled(savedEntry.getLevel() != WifiEntry.WIFI_LEVEL_UNREACHABLE); + preference.setOrder(index++); + + mPreferenceGroup.addPreference(preference); } + + mAddPreference.setOrder(index); + mPreferenceGroup.addPreference(mAddPreference); } - /** Called when the connection state of wifi has changed. */ @Override - public void onConnectedChanged() { + public void onSubscriptionWifiEntriesChanged() { // Do nothing. } - /** - * Called to indicate the list of AccessPoints has been updated and - * getAccessPoints should be called to get the latest information. - */ @Override - public void onAccessPointsChanged() { - updateAccessPointPreferences(); + public void onWifiStateChanged() { + // Do nothing. } @Override - public void onAccessPointChanged(final AccessPoint accessPoint) { - Log.d(TAG, "onAccessPointChanged (singular) callback initiated"); - View view = getView(); - if (view != null) { - view.post(() -> { - final Object tag = accessPoint.getTag(); - if (tag != null) { - ((AccessPointPreference) tag).refresh(); - } - }); - } - } - - @Override - public void onLevelChanged(AccessPoint accessPoint) { - ((AccessPointPreference) accessPoint.getTag()).onLevelChanged(); - } - - @Override - public boolean onPreferenceTreeClick(Preference preference) { - if (preference instanceof AccessPointPreference) { - final AccessPoint selectedAccessPoint = - ((AccessPointPreference) preference).getAccessPoint(); - if (selectedAccessPoint == null) { - return false; - } + public boolean onPreferenceClick(Preference preference) { + if (preference instanceof WifiEntryPreference) { + final WifiEntry selectedWifiEntry = ((WifiEntryPreference) preference).getWifiEntry(); // Launch WifiDppAddDeviceFragment to start DPP in Configurator-Initiator role. - final WifiConfiguration wifiConfig = selectedAccessPoint.getConfig(); + final WifiConfiguration wifiConfig = selectedWifiEntry.getWifiConfiguration(); if (wifiConfig == null) { throw new IllegalArgumentException("Invalid access point"); } final WifiNetworkConfig networkConfig = WifiNetworkConfig.getValidConfigOrNull( - selectedAccessPoint.getSecurityString(/* concise */ true), + selectedWifiEntry.getSecurityString(/* concise */ true), wifiConfig.getPrintableSsid(), wifiConfig.preSharedKey, wifiConfig.hiddenSSID, wifiConfig.networkId, /* isHotspot */ false); if (mOnChooseNetworkListener != null) { mOnChooseNetworkListener.onChooseNetwork(networkConfig); } } else if (preference == mAddPreference) { - launchAddNetworkFragment(); - } else if (preference == mFakeNetworkPreference) { - if (mOnChooseNetworkListener != null) { - mOnChooseNetworkListener.onChooseNetwork( - new WifiNetworkConfig( - WifiQrCode.SECURITY_WPA_PSK, - /* ssid */ WifiNetworkConfig.FAKE_SSID, - /* preSharedKey */ WifiNetworkConfig.FAKE_PASSWORD, - /* hiddenSsid */ true, - /* networkId */ WifiConfiguration.INVALID_NETWORK_ID, - /* isHotspot*/ false)); - } + new SubSettingLauncher(getContext()) + .setTitleRes(R.string.wifi_add_network) + .setDestination(AddNetworkFragment.class.getName()) + .setSourceMetricsCategory(getMetricsCategory()) + .setResultListener(this, ADD_NETWORK_REQUEST) + .launch(); } else { return super.onPreferenceTreeClick(preference); } return true; } - private void handleAddNetworkSubmitEvent(Intent data) { - final WifiConfiguration wifiConfiguration = data.getParcelableExtra(WIFI_CONFIG_KEY); - if (wifiConfiguration != null) { - mWifiManager.save(wifiConfiguration, mSaveListener); - } - } - - private boolean isValidForDppConfiguration(AccessPoint accessPoint) { - final int security = accessPoint.getSecurity(); + private boolean isValidForDppConfiguration(WifiEntry wifiEntry) { + final int security = wifiEntry.getSecurity(); // DPP 1.0 only support PSK and SAE. - return security == AccessPoint.SECURITY_PSK || security == AccessPoint.SECURITY_SAE; - } - - private void launchAddNetworkFragment() { - new SubSettingLauncher(getContext()) - .setTitleRes(R.string.wifi_add_network) - .setDestination(AddNetworkFragment.class.getName()) - .setSourceMetricsCategory(getMetricsCategory()) - .setResultListener(this, ADD_NETWORK_REQUEST) - .launch(); - } - - private void removeAccessPointPreferences() { - mAccessPointsPreferenceCategory.removeAll(); - mAccessPointsPreferenceCategory.setVisible(false); - } - - private void updateAccessPointPreferences() { - // in case state has changed - if (!mWifiManager.isWifiEnabled()) { - return; - } - - List savedAccessPoints = - WifiSavedConfigUtils.getAllConfigs(getContext(), mWifiManager); - - savedAccessPoints = savedAccessPoints.stream() - .filter(accessPoint -> isValidForDppConfiguration(accessPoint)) - .map(accessPoint -> getScannedAccessPointIfAvailable(accessPoint)) - .sorted((ap1, ap2) -> { - // orders reachable Wi-Fi networks on top - if (ap1.isReachable() && !ap2.isReachable()) { - return -1; - } else if (!ap1.isReachable() && ap2.isReachable()) { - return 1; - } - - String ap1Title = nullToEmpty(ap1.getTitle()); - String ap2Title = nullToEmpty(ap2.getTitle()); - - return ap1Title.compareToIgnoreCase(ap2Title); - }).collect(Collectors.toList()); - - int index = 0; - mAccessPointsPreferenceCategory.removeAll(); - for (AccessPoint savedAccessPoint : savedAccessPoints) { - final AccessPointPreference preference = - createAccessPointPreference(savedAccessPoint); - - preference.setOrder(index++); - preference.setEnabled(savedAccessPoint.isReachable()); - savedAccessPoint.setListener(this); - - preference.refresh(); - mAccessPointsPreferenceCategory.addPreference(preference); - } - mAddPreference.setOrder(index); - mAccessPointsPreferenceCategory.addPreference(mAddPreference); - - if (mIsTest) { - mAccessPointsPreferenceCategory.addPreference(mFakeNetworkPreference); - } - } - - private String nullToEmpty(String string) { - return (string == null) ? "" : string; - } - - // Replaces with an AccessPoint from scanned result for signal information - private AccessPoint getScannedAccessPointIfAvailable(AccessPoint savedAccessPoint) { - final List scannedAccessPoints = mWifiTracker.getAccessPoints(); - final WifiConfiguration savedWifiConfiguration = savedAccessPoint.getConfig(); - for (AccessPoint scannedAccessPoint : scannedAccessPoints) { - if (scannedAccessPoint.matches(savedWifiConfiguration)) { - return scannedAccessPoint; - } - } - return savedAccessPoint; - } - - private AccessPointPreference createAccessPointPreference(AccessPoint accessPoint) { - return new AccessPointPreference(accessPoint, getPrefContext(), mUserBadgeCache, - R.drawable.ic_wifi_signal_0, /* forSavedNetworks */ false); + return security == WifiEntry.SECURITY_PSK || security == WifiEntry.SECURITY_SAE; } } diff --git a/tests/robotests/src/com/android/settings/wifi/dpp/WifiNetworkListFragmentTest.java b/tests/robotests/src/com/android/settings/wifi/dpp/WifiNetworkListFragmentTest.java new file mode 100644 index 00000000000..f212a90367c --- /dev/null +++ b/tests/robotests/src/com/android/settings/wifi/dpp/WifiNetworkListFragmentTest.java @@ -0,0 +1,142 @@ +/* + * 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. + */ + +package com.android.settings.wifi.dpp; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import android.app.Activity; +import android.content.Context; +import android.content.Intent; +import android.net.wifi.WifiConfiguration; +import android.net.wifi.WifiManager; + +import androidx.preference.Preference; +import androidx.preference.PreferenceCategory; +import androidx.test.InstrumentationRegistry; + +import com.android.settingslib.wifi.WifiEntryPreference; +import com.android.wifitrackerlib.SavedNetworkTracker; +import com.android.wifitrackerlib.WifiEntry; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.MockitoAnnotations; +import org.robolectric.RobolectricTestRunner; + +import java.util.Arrays; + +@RunWith(RobolectricTestRunner.class) +public class WifiNetworkListFragmentTest { + private WifiNetworkListFragment mWifiNetworkListFragment; + private Context mContext; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + mContext = spy(InstrumentationRegistry.getTargetContext()); + mWifiNetworkListFragment = spy(new WifiNetworkListFragment()); + doReturn(mContext).when(mWifiNetworkListFragment).getContext(); + mWifiNetworkListFragment.mWifiManager = mock(WifiManager.class); + mWifiNetworkListFragment.mSavedNetworkTracker = mock(SavedNetworkTracker.class); + mWifiNetworkListFragment.mPreferenceGroup = mock(PreferenceCategory.class); + mWifiNetworkListFragment.mAddPreference = mock(Preference.class); + mWifiNetworkListFragment.mOnChooseNetworkListener = + mock(WifiNetworkListFragment.OnChooseNetworkListener.class); + } + + @Test + public void onActivityResult_addNetworkRequestOk_shouldSaveNetwork() { + final WifiConfiguration wifiConfig = new WifiConfiguration(); + final Intent intent = new Intent(); + intent.putExtra(WifiNetworkListFragment.WIFI_CONFIG_KEY, wifiConfig); + + mWifiNetworkListFragment.onActivityResult(WifiNetworkListFragment.ADD_NETWORK_REQUEST, + Activity.RESULT_OK, intent); + + verify(mWifiNetworkListFragment.mWifiManager).save(eq(wifiConfig), any()); + } + + @Test + public void onSavedWifiEntriesChanged_noSavedWifiEntry_onlyAddNetworkPreference() { + when(mWifiNetworkListFragment.mSavedNetworkTracker.getSavedWifiEntries()) + .thenReturn(Arrays.asList()); + + mWifiNetworkListFragment.onSavedWifiEntriesChanged(); + + verify(mWifiNetworkListFragment.mPreferenceGroup).addPreference( + mWifiNetworkListFragment.mAddPreference); + } + + @Test + public void onSavedWifiEntriesChanged_openSavedWifiEntry_onlyAddNetworkPreference() { + final WifiEntry wifiEntry = mock(WifiEntry.class); + when(wifiEntry.getSecurity()).thenReturn(WifiEntry.SECURITY_NONE); + when(mWifiNetworkListFragment.mSavedNetworkTracker.getSavedWifiEntries()) + .thenReturn(Arrays.asList(wifiEntry)); + + mWifiNetworkListFragment.onSavedWifiEntriesChanged(); + + verify(mWifiNetworkListFragment.mPreferenceGroup).addPreference( + mWifiNetworkListFragment.mAddPreference); + } + + @Test + public void onSavedWifiEntriesChanged_pskSavedWifiEntry_add2Preferences() { + final WifiEntry wifiEntry = mock(WifiEntry.class); + when(wifiEntry.getSecurity()).thenReturn(WifiEntry.SECURITY_PSK); + when(mWifiNetworkListFragment.mSavedNetworkTracker.getSavedWifiEntries()) + .thenReturn(Arrays.asList(wifiEntry)); + + mWifiNetworkListFragment.onSavedWifiEntriesChanged(); + + verify(mWifiNetworkListFragment.mPreferenceGroup, times(2)).addPreference(any()); + } + + @Test + public void onSavedWifiEntriesChanged_saeSavedWifiEntry_add2Preferences() { + final WifiEntry wifiEntry = mock(WifiEntry.class); + when(wifiEntry.getSecurity()).thenReturn(WifiEntry.SECURITY_SAE); + when(mWifiNetworkListFragment.mSavedNetworkTracker.getSavedWifiEntries()) + .thenReturn(Arrays.asList(wifiEntry)); + + mWifiNetworkListFragment.onSavedWifiEntriesChanged(); + + verify(mWifiNetworkListFragment.mPreferenceGroup, times(2)).addPreference(any()); + } + + @Test + public void onPreferenceClick_validWifiEntryPreference_onChooseNetwork() { + final WifiEntry wifiEntry = mock(WifiEntry.class); + when(wifiEntry.getSecurityString(true /* concise */)).thenReturn("WPA3"); + final WifiConfiguration wifiConfig = mock(WifiConfiguration.class); + when(wifiConfig.getPrintableSsid()).thenReturn("ssid"); + when(wifiEntry.getWifiConfiguration()).thenReturn(wifiConfig); + final WifiEntryPreference preference = new WifiEntryPreference(mContext, wifiEntry); + + mWifiNetworkListFragment.onPreferenceClick(preference); + + verify(mWifiNetworkListFragment.mOnChooseNetworkListener).onChooseNetwork(any()); + } +} diff --git a/tests/unit/src/com/android/settings/wifi/dpp/WifiNetworkListFragmentTest.java b/tests/unit/src/com/android/settings/wifi/dpp/WifiNetworkListFragmentTest.java deleted file mode 100644 index fec0c6fa40c..00000000000 --- a/tests/unit/src/com/android/settings/wifi/dpp/WifiNetworkListFragmentTest.java +++ /dev/null @@ -1,169 +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.dpp; - -import static androidx.test.espresso.Espresso.onView; -import static androidx.test.espresso.assertion.ViewAssertions.matches; -import static androidx.test.espresso.matcher.ViewMatchers.isDisplayed; -import static androidx.test.espresso.matcher.ViewMatchers.withText; - -import static com.google.common.truth.Truth.assertThat; - -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.Uri; -import android.net.wifi.WifiConfiguration; -import android.net.wifi.WifiInfo; -import android.net.wifi.WifiManager; -import android.provider.Settings; - -import androidx.fragment.app.Fragment; -import androidx.test.InstrumentationRegistry; -import androidx.test.rule.ActivityTestRule; -import androidx.test.runner.AndroidJUnit4; - -import com.android.settingslib.wifi.AccessPoint; -import com.android.settingslib.wifi.WifiTracker; -import com.android.settingslib.wifi.WifiTrackerFactory; - -import com.google.common.collect.Lists; - -import org.junit.Before; -import org.junit.Rule; -import org.junit.Test; -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 WifiNetworkListFragmentTest { - 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_DPP_URL = "DPP:C:81/1;I:DPP_TESTER;K:" - + "MDkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDIgADUysZxnwRFGQR7Fepipjl84TG/dQR07es91iOB3PkPOk=;;"; - - // 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_DISPLAY_STATUS_CONNECTED = "wifi_display_status_connected"; - - @Mock - private WifiTracker mWifiTracker; - @Mock - private WifiManager mWifiManager; - - private WifiNetworkListFragment mWifiNetworkListFragment; - private Context mContext; - - @Rule - public ActivityTestRule mActivityRule = new ActivityTestRule<>( - WifiDppConfiguratorActivity.class, true); - - @Before - public void setUp() { - MockitoAnnotations.initMocks(this); - mContext = InstrumentationRegistry.getTargetContext(); - WifiTrackerFactory.setTestingWifiTracker(mWifiTracker); - when(mWifiTracker.getManager()).thenReturn(mWifiManager); - } - - private void callOnWifiStateChanged(int state) { - mActivityRule.getActivity().getMainThreadHandler() - .post(() -> mWifiNetworkListFragment.onWifiStateChanged(state)); - } - - /** Launch the activity via an Intent with data Uri */ - private void launchActivity(String uriString) { - final Intent intent = new Intent(Settings.ACTION_PROCESS_WIFI_EASY_CONNECT_URI); - intent.setData(Uri.parse(uriString)); - mActivityRule.launchActivity(intent); - - List fragments = - mActivityRule.getActivity().getSupportFragmentManager().getFragments(); - assertThat(fragments.size()).isEqualTo(1); - List childFragments = fragments.get(0).getChildFragmentManager().getFragments(); - assertThat(childFragments.size()).isEqualTo(1); - mWifiNetworkListFragment = (WifiNetworkListFragment) childFragments.get(0); - assertThat(mWifiNetworkListFragment).isNotNull(); - } - - private int resourceId(String type, String name) { - return mContext.getResources().getIdentifier(name, type, mContext.getPackageName()); - } - - /** Similar to {@link #resourceId}, but for accessing R.string. values. */ - private String resourceString(String name) { - return mContext.getResources().getString(resourceId(STRING, name)); - } - - private void setWifiState(int wifiState) { - when(mWifiManager.getWifiState()).thenReturn(wifiState); - when(mWifiManager.isWifiEnabled()).thenReturn(wifiState == WifiManager.WIFI_STATE_ENABLED); - } - - private void setupConnectedAccessPoint() { - final WifiConfiguration config = new WifiConfiguration(); - config.SSID = TEST_SSID; - config.BSSID = TEST_BSSID; - config.networkId = TEST_NETWORK_ID; - config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK); - final WifiInfo wifiInfo = new WifiInfo.Builder() - .setSsid(TEST_UNQUOTED_SSID.getBytes(StandardCharsets.UTF_8)) - .setBssid(TEST_BSSID) - .setRssi(TEST_RSSI) - .setNetworkId(TEST_NETWORK_ID) - .build(); - final NetworkInfo networkInfo = new NetworkInfo(ConnectivityManager.TYPE_WIFI, 0, null, null); - networkInfo.setDetailedState(NetworkInfo.DetailedState.CONNECTED, null, null); - final 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[]{})); - } - - @Test - public void onConnected_shouldSeeConnectedMessage() throws Exception { - setWifiState(WifiManager.WIFI_STATE_ENABLED); - setupConnectedAccessPoint(); - when(mWifiTracker.isConnected()).thenReturn(true); - - launchActivity(TEST_DPP_URL); - callOnWifiStateChanged(WifiManager.WIFI_STATE_ENABLED); - - onView(withText(resourceString(WIFI_DISPLAY_STATUS_CONNECTED))).check( - matches(isDisplayed())); - } -}