[Wi-Fi] Refactor AddAppNetworksFragment to use WifiEntry but not AccessPoint.

import android.content.Intent;

import android.content.pm.PackageManager;

import android.graphics.drawable.Drawable;

import android.net.ConnectivityManager;

import android.net.NetworkScoreManager;

import android.net.wifi.WifiConfiguration;

import android.net.wifi.WifiConfiguration.KeyMgmt;

import android.net.wifi.WifiManager;

import android.net.wifi.hotspot2.PasspointConfiguration;

import android.os.Bundle;

import android.os.Handler;

import android.os.HandlerThread;

import android.os.Looper;

import android.os.Message;

import android.os.Process;

import android.os.SimpleClock;

import android.os.SystemClock;

import android.provider.Settings;

import android.text.TextUtils;

import android.util.Log;

import com.android.settings.R;

import com.android.settings.Utils;

import com.android.settings.core.InstrumentedFragment;

import com.android.settingslib.wifi.AccessPoint;

import com.android.settingslib.wifi.WifiTracker;

import com.android.settingslib.wifi.WifiTrackerFactory;

import com.android.wifitrackerlib.WifiEntry;

import com.android.wifitrackerlib.WifiPickerTracker;

import java.time.Clock;

import java.time.ZoneOffset;

import java.util.ArrayList;

import java.util.List;

import java.util.Optional;

 * choose on either saving those networks or rejecting the request.

 */

public class AddAppNetworksFragment extends InstrumentedFragment implements

        WifiTracker.WifiListener {

        WifiPickerTracker.WifiPickerTrackerCallback {

    public static final String TAG = "AddAppNetworksFragment";

    // Possible result values in each item of the returned result list, which is used

    // Signal level for the initial signal icon.

    @VisibleForTesting

    static final int INITIAL_RSSI_SIGNAL_LEVEL = 0;

    // Max networks count within one request

    // Max networks count within one request.

    private static final int MAX_SPECIFIC_NETWORKS_COUNT = 5;

    // Duration for showing different status message.

    private static final long SHOW_SAVING_INTERVAL_MILLIS = 500L;

    private static final long SHOW_SAVED_INTERVAL_MILLIS = 1000L;

    // Max age of tracked WifiEntries.

    private static final long MAX_SCAN_AGE_MILLIS = 15_000;

    // Interval between initiating WifiPickerTracker scans.

    private static final long SCAN_INTERVAL_MILLIS = 10_000;

    @VisibleForTesting

    FragmentActivity mActivity;

    @VisibleForTesting

    @VisibleForTesting

    List<Integer> mResultCodeArrayList;

    @VisibleForTesting

    WifiTracker mWifiTracker;

    WifiPickerTracker mWifiPickerTracker;

    private boolean mIsSingleNetwork;

    private boolean mAnyNetworkSavedSuccess;

    private UiConfigurationItemAdapter mUiConfigurationItemAdapter;

    private WifiManager.ActionListener mSaveListener;

    private WifiManager mWifiManager;

    // Worker thread used for WifiPickerTracker work

    private HandlerThread mWorkerThread;

    private final Handler mHandler = new Handler() {

        @Override

            @Nullable Bundle savedInstanceState) {

        mActivity = getActivity();

        mWifiManager = mActivity.getSystemService(WifiManager.class);

        mWifiTracker = WifiTrackerFactory.create(mActivity.getApplication(), this,

                getSettingsLifecycle(), true /* includeSaved */, true /* includeScans */);

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

            }

        };

        mWifiPickerTracker = new WifiPickerTracker(getSettingsLifecycle(), mActivity,

                mActivity.getSystemService(WifiManager.class),

                mActivity.getSystemService(ConnectivityManager.class),

                mActivity.getSystemService(NetworkScoreManager.class),

                new Handler(Looper.getMainLooper()),

                mWorkerThread.getThreadHandler(),

                elapsedRealtimeClock,

                MAX_SCAN_AGE_MILLIS,

                SCAN_INTERVAL_MILLIS,

                this);

        return inflater.inflate(R.layout.wifi_add_app_networks, container, false);

    }

        }

    }

    @Override

    public void onWifiStateChanged(int state) {

        // Do nothing

    }

    @Override

    public void onConnectedChanged() {

        // Do nothing

    }

    @VisibleForTesting

    void updateScanResultsToUi(List<AccessPoint> allAccessPoints) {

    void updateScanResultsToUi(List<WifiEntry> allEntries) {

        if (mUiToRequestedList == null) {

            // Nothing need to be updated.

            return;

        // Update the signal level of the UI networks.

        for (UiConfigurationItem uiConfigurationItem : mUiToRequestedList) {

            uiConfigurationItem.mLevel = 0;

            if (allAccessPoints != null) {

                final Optional<AccessPoint> matchedAccessPoint = allAccessPoints

                        .stream()

                        .filter(accesspoint -> accesspoint.matches(

                                uiConfigurationItem.mWifiNetworkSuggestion.getWifiConfiguration()))

            if (allEntries != null) {

                final Optional<WifiEntry> matchedWifiEntry = allEntries.stream()

                        .filter(wifiEntry -> TextUtils.equals(

                                uiConfigurationItem.mWifiNetworkSuggestion.getSsid(),

                                wifiEntry.getSsid()))

                        .filter(wifiEntry -> !wifiEntry.isSaved())

                        .findFirst();

                uiConfigurationItem.mLevel =

                        matchedAccessPoint.isPresent() ? matchedAccessPoint.get().getLevel() : 0;

                        matchedWifiEntry.isPresent() ? matchedWifiEntry.get().getLevel() : 0;

            }

        }

    @Override

    public void onResume() {

        super.onResume();

        onAccessPointsChanged();

        onWifiEntriesChanged();

    }

    /** Called when the state of Wifi has changed. */

    @Override

    public void onWifiStateChanged() {

        onWifiEntriesChanged();

    }

    /**

     * Update the results when data changes

     */

    @Override

    public void onAccessPointsChanged() {

    public void onWifiEntriesChanged() {

        updateScanResultsToUi(

                mWifiTracker.getManager().isWifiEnabled() ? mWifiTracker.getAccessPoints() : null);

                (mWifiPickerTracker.getWifiState() == WifiManager.WIFI_STATE_ENABLED)

                        ? mWifiPickerTracker.getWifiEntries() : null);

    }

    @Override

    public void onNumSavedSubscriptionsChanged() {

        // Do nothing.

    }

    @Override

    public void onNumSavedNetworksChanged() {

        // Do nothing.

    }

}

import static com.google.common.truth.Truth.assertThat;

import static org.mockito.ArgumentMatchers.any;

import static org.mockito.Mockito.doReturn;

import static org.mockito.Mockito.spy;

import static org.mockito.Mockito.when;

import androidx.annotation.NonNull;

import com.android.settings.R;

import com.android.settingslib.wifi.AccessPoint;

import com.android.settingslib.wifi.WifiTracker;

import com.android.settingslib.wifi.WifiTrackerFactory;

import com.android.wifitrackerlib.WifiEntry;

import com.android.wifitrackerlib.WifiPickerTracker;

import org.junit.Before;

import org.junit.Test;

@RunWith(RobolectricTestRunner.class)

public class AddAppNetworksFragmentTest {

    private static final String FAKE_APP_NAME = "fake_app_name";

    private static final String FAKE_NEW_WPA_SSID = "fake_new_wpa_ssid";

    private static final String FAKE_NEW_OPEN_SSID = "fake_new_open_ssid";

    private ArrayList<Integer> mFakedResultArrayList = new ArrayList<>();

    @Mock

    private AccessPoint mMockAccessPoint;

    private WifiEntry mMockWifiEntry;

    @Mock

    private WifiTracker mMockWifiTracker;

    private WifiPickerTracker mMockWifiPickerTracker;

    @Mock

    private WifiManager mMockWifiManager;

                WifiConfiguration.KeyMgmt.NONE, null);

        mSavedWpaConfigurationEntry = generateRegularWifiConfiguration(FAKE_NEW_SAVED_WPA_SSID,

                WifiConfiguration.KeyMgmt.WPA_PSK, "\"1234567890\"");

        when(mMockWifiTracker.getManager()).thenReturn(mMockWifiManager);

        when(mMockWifiManager.isWifiEnabled()).thenReturn(true);

        mAddAppNetworksFragment.mWifiTracker = mMockWifiTracker;

        WifiTrackerFactory.setTestingWifiTracker(mMockWifiTracker);

        mAddAppNetworksFragment.mWifiPickerTracker = mMockWifiPickerTracker;

        setUpOneScannedNetworkWithScanedLevel4();

    }

    @Test

    public void withOneSuggestion_whenScanResultChanged_uiListShouldHaveNewLevel() {

        // Arrange

        when(mAddAppNetworksFragment.mWifiTracker.getManager().isWifiEnabled()).thenReturn(true);

        when(mMockWifiPickerTracker.getWifiState()).thenReturn(WifiManager.WIFI_STATE_ENABLED);

        // Setup a fake saved network list and assign to fragment.

        addOneSavedNetworkConfiguration(mSavedWpaConfigurationEntry);

        // Setup one specified networks and its results and assign to fragment.

        mAddAppNetworksFragment.filterSavedNetworks(mFakeSavedNetworksList);

        // Act

        mAddAppNetworksFragment.onAccessPointsChanged();

        mAddAppNetworksFragment.onWifiEntriesChanged();

        // Assert

        assertThat(mAddAppNetworksFragment.mUiToRequestedList.get(0).mLevel).isEqualTo(

    @Test

    public void withOneSuggestion_whenScanResultChangedButWifiOff_uiListShouldHaveZeroLevel() {

        // Arrange

        when(mAddAppNetworksFragment.mWifiTracker.getManager().isWifiEnabled()).thenReturn(false);

        when(mMockWifiPickerTracker.getWifiState()).thenReturn(WifiManager.WIFI_STATE_DISABLED);

        // Setup a fake saved network list and assign to fragment.

        addOneSavedNetworkConfiguration(mSavedWpaConfigurationEntry);

        // Setup one specified networks and its results and assign to fragment.

        mAddAppNetworksFragment.filterSavedNetworks(mFakeSavedNetworksList);

        // Act

        mAddAppNetworksFragment.onAccessPointsChanged();

        mAddAppNetworksFragment.onWifiEntriesChanged();

        // Assert

        assertThat(mAddAppNetworksFragment.mUiToRequestedList.get(0).mLevel).isEqualTo(

    private void setUpOneScannedNetworkWithScanedLevel4() {

        final ArrayList list = new ArrayList<>();

        list.add(mMockAccessPoint);

        when(mMockWifiTracker.getAccessPoints()).thenReturn(list);

        when(mMockAccessPoint.getSsidStr()).thenReturn(FAKE_NEW_OPEN_SSID);

        when(mMockAccessPoint.matches(any(WifiConfiguration.class))).thenReturn(true);

        when(mMockAccessPoint.getLevel()).thenReturn(SCANED_LEVEL4);

        list.add(mMockWifiEntry);

        when(mMockWifiPickerTracker.getWifiEntries()).thenReturn(list);

        when(mMockWifiEntry.getSsid()).thenReturn(FAKE_NEW_OPEN_SSID);

        when(mMockWifiEntry.getLevel()).thenReturn(SCANED_LEVEL4);

    }

    private void addOneSavedNetworkConfiguration(@NonNull WifiConfiguration wifiConfiguration) {