Merge "[Wi-Fi] Apply WifiTrackerLib objects in wifi/dpp/WifiNetworkListFragment"

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;

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
      */

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;

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.os.Handler;
-import android.view.View;
+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.WifiEntryPreference;
-import com.android.settingslib.wifi.AccessPointPreference;
+import com.android.wifitrackerlib.SavedNetworkTracker;
-import com.android.settingslib.wifi.WifiSavedConfigUtils;
+import com.android.wifitrackerlib.WifiEntry;
-import com.android.settingslib.wifi.WifiTracker;
-import com.android.settingslib.wifi.WifiTrackerFactory;
 
+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;
+    @VisibleForTesting PreferenceCategory mPreferenceGroup;
-    private AccessPointPreference.UserBadgeCache mUserBadgeCache;
+    @VisibleForTesting Preference mAddPreference;
-    private Preference mAddPreference;
-    // Only shows up if mIsTest == true
-    private Preference mFakeNetworkPreference;
 
-    private WifiManager mWifiManager;
+    @VisibleForTesting WifiManager mWifiManager;
-    private WifiTracker mWifiTracker;
 
     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,
+        final Context context = getContext();
-                getSettingsLifecycle(), /* includeSaved */true, /* includeScans */ true);
+        mWifiManager = context.getSystemService(WifiManager.class);
-        mWifiManager = mWifiTracker.getManager();
-
-        final Bundle args = getArguments();
-        if (args != null) {
-            mIsTest = args.getBoolean(WifiDppUtils.EXTRA_TEST, false);
-        }
 
         mSaveListener = new WifiManager.ActionListener() {
             @Override
@@ -111,25 +128,45 @@ public class WifiNetworkListFragment extends SettingsPreferenceFragment implemen
 
             @Override
             public void onFailure(int reason) {
-                Activity activity = getActivity();
+                final Activity activity = getActivity();
-                if (activity != null) {
+                if (activity != null && !activity.isFinishing()) {
-                    Toast.makeText(activity,
+                    Toast.makeText(activity, R.string.wifi_failed_save_message,
-                            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 (requestCode == ADD_NETWORK_REQUEST && resultCode == Activity.RESULT_OK) {
-            if (resultCode == Activity.RESULT_OK) {
+            final WifiConfiguration wifiConfiguration = data.getParcelableExtra(WIFI_CONFIG_KEY);
-                handleAddNetworkSubmitEvent(data);
+            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);
+        mPreferenceGroup = 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");
 
         mAddPreference = new Preference(getPrefContext());
         mAddPreference.setIcon(R.drawable.ic_add_24dp);
         mAddPreference.setTitle(R.string.wifi_add_network);
-
+        mAddPreference.setOnPreferenceClickListener(this);
-        mUserBadgeCache = new AccessPointPreference.UserBadgeCache(getPackageManager());
     }
 
     /** Called when the state of Wifi has changed. */
     @Override
-    public void onWifiStateChanged(int state) {
+    public void onSavedWifiEntriesChanged() {
-        final int wifiState = mWifiManager.getWifiState();
+        final List<WifiEntry> savedWifiEntries = mSavedNetworkTracker.getSavedWifiEntries().stream()
-        switch (wifiState) {
+                .filter(entry -> isValidForDppConfiguration(entry))
-            case WifiManager.WIFI_STATE_ENABLED:
+                .collect(Collectors.toList());
-                updateAccessPointPreferences();
-                break;
 
-            case WifiManager.WIFI_STATE_ENABLING:
+        int index = 0;
-            case WifiManager.WIFI_STATE_DISABLING:
+        mPreferenceGroup.removeAll();
-                removeAccessPointPreferences();
+        for (WifiEntry savedEntry : savedWifiEntries) {
-                break;
+            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() {
+    public void onWifiStateChanged() {
-        updateAccessPointPreferences();
+        // Do nothing.
     }
 
     @Override
-    public void onAccessPointChanged(final AccessPoint accessPoint) {
+    public boolean onPreferenceClick(Preference preference) {
-        Log.d(TAG, "onAccessPointChanged (singular) callback initiated");
+        if (preference instanceof WifiEntryPreference) {
-        View view = getView();
+            final WifiEntry selectedWifiEntry = ((WifiEntryPreference) preference).getWifiEntry();
-        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;
-            }
 
             // 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));
-            }
-        } 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();
-
-        // 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();
+        } else {
+            return super.onPreferenceTreeClick(preference);
+        }
+        return true;
     }
 
-    private void removeAccessPointPreferences() {
+    private boolean isValidForDppConfiguration(WifiEntry wifiEntry) {
-        mAccessPointsPreferenceCategory.removeAll();
+        final int security = wifiEntry.getSecurity();
-        mAccessPointsPreferenceCategory.setVisible(false);
-    }
 
-    private void updateAccessPointPreferences() {
+        // DPP 1.0 only support PSK and SAE.
-        // in case state has changed
+        return security == WifiEntry.SECURITY_PSK || security == WifiEntry.SECURITY_SAE;
-        if (!mWifiManager.isWifiEnabled()) {
-            return;
-        }
-
-        List<AccessPoint> 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<AccessPoint> 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);
     }
 }

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());
+    }
+}

tests/unit/src/com/android/settings/wifi/dpp/WifiNetworkListFragmentTest.java

@@ -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<WifiDppConfiguratorActivity> 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<Fragment> fragments =
-                mActivityRule.getActivity().getSupportFragmentManager().getFragments();
-        assertThat(fragments.size()).isEqualTo(1);
-        List<Fragment> 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.<name> 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()));
-    }
-}