Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit ebf8ffd8 authored by Arc Wang's avatar Arc Wang
Browse files

[Wi-Fi] Refactor WifiConnectionPreferenceController with WifiTrackerLib 

Bug: 152582093
Test: make RunSettingsRoboTests ROBOTEST_FILTER=WifiConnectionPreferenceControllerTest
Change-Id: I9c0ab0edf5a8e935a2c1afee865bd04304ae6f0f
parent ef840837

src/com/android/settings/wifi/WifiConnectionPreferenceController.java

+90 −74
Original line number Diff line number Diff line
@@ -17,22 +17,32 @@ 
package com.android.settings.wifi;



import android.content.Context;

import android.net.ConnectivityManager;

import android.net.NetworkScoreManager;

import android.net.wifi.WifiManager;

import android.os.Bundle;

import android.util.FeatureFlagUtils;



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 androidx.annotation.VisibleForTesting;

import androidx.preference.PreferenceGroup;

import androidx.preference.PreferenceScreen;



import com.android.settings.R;

import com.android.settings.core.SubSettingLauncher;

import com.android.settings.wifi.details.WifiNetworkDetailsFragment;

import com.android.settings.wifi.details2.WifiNetworkDetailsFragment2;

import com.android.settingslib.core.AbstractPreferenceController;

import com.android.settingslib.core.lifecycle.Lifecycle;

import com.android.settingslib.wifi.AccessPoint;

import com.android.settingslib.wifi.AccessPointPreference;

import com.android.settingslib.wifi.WifiTracker;

import com.android.settingslib.wifi.WifiTrackerFactory;

import com.android.settingslib.wifi.WifiEntryPreference;

import com.android.wifitrackerlib.WifiEntry;

import com.android.wifitrackerlib.WifiPickerTracker;



import java.time.Clock;

import java.time.ZoneOffset;



// TODO(b/151133650): Replace AbstractPreferenceController with BasePreferenceController.

/**
@@ -40,21 +50,28 @@ import com.android.settingslib.wifi.WifiTrackerFactory; 
 * controller class when there is a wifi connection present.

 */

public class WifiConnectionPreferenceController extends AbstractPreferenceController implements

        WifiTracker.WifiListener {

        WifiPickerTracker.WifiPickerTrackerCallback {



    private static final String TAG = "WifiConnPrefCtrl";



    private static final String KEY = "active_wifi_connection";



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



    private UpdateListener mUpdateListener;

    private Context mPrefContext;

    private String mPreferenceGroupKey;

    private PreferenceGroup mPreferenceGroup;

    private WifiTracker mWifiTracker;

    private AccessPointPreference mPreference;

    private AccessPointPreference.UserBadgeCache mBadgeCache;

    @VisibleForTesting

    public WifiPickerTracker mWifiPickerTracker;

    private WifiEntryPreference mPreference;

    private int order;

    private int mMetricsCategory;

    // Worker thread used for WifiPickerTracker work.

    private HandlerThread mWorkerThread;



    /**

     * Used to notify a parent controller that this controller has changed in availability, or has
@@ -82,16 +99,34 @@ public class WifiConnectionPreferenceController extends AbstractPreferenceContro 
        super(context);

        mUpdateListener = updateListener;

        mPreferenceGroupKey = preferenceGroupKey;

        mWifiTracker = WifiTrackerFactory.create(context, this, lifecycle, true /* includeSaved */,

                true /* includeScans */);

        this.order = order;

        mMetricsCategory = metricsCategory;

        mBadgeCache = new AccessPointPreference.UserBadgeCache(context.getPackageManager());



        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(lifecycle, 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 boolean isAvailable() {

        return mWifiTracker.isConnected() && getCurrentAccessPoint() != null;

        return mWifiPickerTracker.getConnectedWifiEntry() != null;

    }



    @Override
@@ -107,34 +142,23 @@ public class WifiConnectionPreferenceController extends AbstractPreferenceContro 
        update();

    }



    private AccessPoint getCurrentAccessPoint() {

        for (AccessPoint accessPoint : mWifiTracker.getAccessPoints()) {

            if (accessPoint.isActive()) {

                return accessPoint;

            }

        }

        return null;

    }



    private void updatePreference(AccessPoint accessPoint) {

    private void updatePreference(WifiEntry wifiEntry) {

        if (mPreference != null) {

            mPreferenceGroup.removePreference(mPreference);

            mPreference = null;

        }

        if (accessPoint == null) {

        if (wifiEntry == null || mPrefContext == null) {

            return;

        }

        if (mPrefContext != null) {

            mPreference = new AccessPointPreference(accessPoint, mPrefContext, mBadgeCache,

                    R.drawable.ic_wifi_signal_0, false /* forSavedNetworks */);



        mPreference = new WifiEntryPreference(mPrefContext, wifiEntry);

        mPreference.setKey(KEY);

        mPreference.refresh();

        mPreference.setOrder(order);



            if (FeatureFlagUtils.isEnabled(mPrefContext, FeatureFlagUtils.SETTINGS_WIFITRACKER2)) {

        mPreference.setOnPreferenceClickListener(pref -> {

                    Bundle args = new Bundle();

                    mPreference.getAccessPoint().saveWifiState(args);

            final Bundle args = new Bundle();

            args.putString(WifiNetworkDetailsFragment2.KEY_CHOSEN_WIFIENTRY_KEY,

                    wifiEntry.getKey());

            new SubSettingLauncher(mPrefContext)

                    .setTitleRes(R.string.pref_title_network_details)

                    .setDestination(WifiNetworkDetailsFragment2.class.getName())
@@ -143,33 +167,16 @@ public class WifiConnectionPreferenceController extends AbstractPreferenceContro 
                    .launch();

            return true;

        });

            } else {

                mPreference.setOnPreferenceClickListener(pref -> {

                    Bundle args = new Bundle();

                    mPreference.getAccessPoint().saveWifiState(args);

                    new SubSettingLauncher(mPrefContext)

                            .setTitleRes(R.string.pref_title_network_details)

                            .setDestination(WifiNetworkDetailsFragment.class.getName())

                            .setArguments(args)

                            .setSourceMetricsCategory(mMetricsCategory)

                            .launch();

                    return true;

                });

            }

        mPreferenceGroup.addPreference(mPreference);

    }

    }



    private void update() {

        AccessPoint connectedAccessPoint = null;

        if (mWifiTracker.isConnected()) {

            connectedAccessPoint = getCurrentAccessPoint();

        }

        if (connectedAccessPoint == null) {

        final WifiEntry connectedWifiEntry = mWifiPickerTracker.getConnectedWifiEntry();

        if (connectedWifiEntry == null) {

            updatePreference(null);

        } else {

          if (mPreference == null || !mPreference.getAccessPoint().equals(connectedAccessPoint)) {

              updatePreference(connectedAccessPoint);

            if (mPreference == null || !mPreference.getWifiEntry().equals(connectedWifiEntry)) {

                updatePreference(connectedWifiEntry);

            } else if (mPreference != null) {

                mPreference.refresh();

            }
@@ -177,18 +184,27 @@ public class WifiConnectionPreferenceController extends AbstractPreferenceContro 
        mUpdateListener.onChildrenUpdated();

    }



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

    @Override

    public void onWifiStateChanged(int state) {

    public void onWifiStateChanged() {

        update();

    }



    /**

     * Update the results when data changes.

     */

    @Override

    public void onConnectedChanged() {

    public void onWifiEntriesChanged() {

        update();

    }



    @Override

    public void onAccessPointsChanged() {

        update();

    public void onNumSavedSubscriptionsChanged() {

        // Do nothing.

    }



    @Override

    public void onNumSavedNetworksChanged() {

        // Do nothing.

    }

}

tests/robotests/src/com/android/settings/network/WifiConnectionPreferenceControllerTest.java

+44 −51
Original line number Diff line number Diff line
@@ -29,12 +29,15 @@ import static org.mockito.Mockito.when; 


import android.content.Context;



import androidx.lifecycle.LifecycleOwner;

import androidx.preference.PreferenceCategory;

import androidx.preference.PreferenceScreen;



import com.android.settings.wifi.WifiConnectionPreferenceController;

import com.android.settingslib.core.lifecycle.Lifecycle;

import com.android.settingslib.wifi.AccessPoint;

import com.android.settingslib.wifi.AccessPointPreference;

import com.android.settingslib.wifi.WifiTracker;

import com.android.settingslib.wifi.WifiTrackerFactory;

import com.android.settingslib.wifi.WifiEntryPreference;

import com.android.wifitrackerlib.WifiEntry;

import com.android.wifitrackerlib.WifiPickerTracker;



import org.junit.Before;

import org.junit.Test;
@@ -45,19 +48,12 @@ import org.mockito.MockitoAnnotations; 
import org.robolectric.RobolectricTestRunner;

import org.robolectric.RuntimeEnvironment;



import java.util.ArrayList;

import java.util.Arrays;



import androidx.lifecycle.LifecycleOwner;

import androidx.preference.PreferenceCategory;

import androidx.preference.PreferenceScreen;



@RunWith(RobolectricTestRunner.class)

public class WifiConnectionPreferenceControllerTest {

    private static final String KEY = "wifi_connection";



    @Mock

    WifiTracker mWifiTracker;

    WifiPickerTracker mWifiPickerTracker;

    @Mock

    PreferenceScreen mScreen;

    @Mock
@@ -74,7 +70,6 @@ public class WifiConnectionPreferenceControllerTest { 
    public void setUp() {

        MockitoAnnotations.initMocks(this);

        mContext = spy(RuntimeEnvironment.application);

        WifiTrackerFactory.setTestingWifiTracker(mWifiTracker);

        mLifecycleOwner = () -> mLifecycle;

        mLifecycle = new Lifecycle(mLifecycleOwner);

        when(mScreen.findPreference(eq(KEY))).thenReturn(mPreferenceCategory);
@@ -83,49 +78,51 @@ public class WifiConnectionPreferenceControllerTest { 


        mController = new WifiConnectionPreferenceController(mContext, mLifecycle, mUpdateListener,

                KEY, 0, 0);

        mController.mWifiPickerTracker = mWifiPickerTracker;

    }



    @Test

    public void isAvailable_noWiFiConnection_availableIsFalse() {

        when(mWifiTracker.isConnected()).thenReturn(false);

    public void isAvailable_noConnectedWifiEntry_availableIsFalse() {

        when(mWifiPickerTracker.getConnectedWifiEntry()).thenReturn(null);



        assertThat(mController.isAvailable()).isFalse();

    }



    @Test

    public void displayPreference_noWiFiConnection_noPreferenceAdded() {

        when(mWifiTracker.isConnected()).thenReturn(false);

        when(mWifiTracker.getAccessPoints()).thenReturn(new ArrayList<>());

    public void displayPreference_noConnectedWifiEntry_noPreferenceAdded() {

        when(mWifiPickerTracker.getConnectedWifiEntry()).thenReturn(null);



        mController.displayPreference(mScreen);



        verify(mPreferenceCategory, never()).addPreference(any());

    }



    @Test

    public void displayPreference_hasWiFiConnection_preferenceAdded() {

        when(mWifiTracker.isConnected()).thenReturn(true);

        final AccessPoint accessPoint = mock(AccessPoint.class);

        when(accessPoint.isActive()).thenReturn(true);

        when(mWifiTracker.getAccessPoints()).thenReturn(Arrays.asList(accessPoint));

    public void displayPreference_hasConnectedWifiEntry_preferenceAdded() {

        final WifiEntry wifiEntry = mock(WifiEntry.class);

        when(mWifiPickerTracker.getConnectedWifiEntry()).thenReturn(wifiEntry);



        mController.displayPreference(mScreen);

        verify(mPreferenceCategory).addPreference(any(AccessPointPreference.class));

        verify(mPreferenceCategory).addPreference(any(WifiEntryPreference.class));

    }



    @Test

    public void onConnectedChanged_wifiBecameDisconnected_preferenceRemoved() {

        when(mWifiTracker.isConnected()).thenReturn(true);

        final AccessPoint accessPoint = mock(AccessPoint.class);

        final WifiEntry wifiEntry = mock(WifiEntry.class);

        when(mWifiPickerTracker.getConnectedWifiEntry()).thenReturn(wifiEntry);



        when(accessPoint.isActive()).thenReturn(true);

        when(mWifiTracker.getAccessPoints()).thenReturn(Arrays.asList(accessPoint));

        mController.displayPreference(mScreen);

        final ArgumentCaptor<AccessPointPreference> captor = ArgumentCaptor.forClass(

                AccessPointPreference.class);

        final ArgumentCaptor<WifiEntryPreference> captor = ArgumentCaptor.forClass(

                WifiEntryPreference.class);

        verify(mPreferenceCategory).addPreference(captor.capture());

        final AccessPointPreference pref = captor.getValue();

        final WifiEntryPreference pref = captor.getValue();



        when(mWifiTracker.isConnected()).thenReturn(false);

        when(mWifiTracker.getAccessPoints()).thenReturn(new ArrayList<>());

        // Become disconnected.

        when(mWifiPickerTracker.getConnectedWifiEntry()).thenReturn(null);

        final int onUpdatedCountBefore = mOnChildUpdatedCount;

        mController.onConnectedChanged();



        mController.onWifiStateChanged();



        verify(mPreferenceCategory).removePreference(pref);

        assertThat(mOnChildUpdatedCount).isEqualTo(onUpdatedCountBefore + 1);

    }
@@ -133,28 +130,24 @@ public class WifiConnectionPreferenceControllerTest { 


    @Test

    public void onAccessPointsChanged_wifiBecameConnectedToDifferentAP_preferenceReplaced() {

        when(mWifiTracker.isConnected()).thenReturn(true);

        final AccessPoint accessPoint1 = mock(AccessPoint.class);



        when(accessPoint1.isActive()).thenReturn(true);

        when(mWifiTracker.getAccessPoints()).thenReturn(Arrays.asList(accessPoint1));

        final WifiEntry wifiEntry1 = mock(WifiEntry.class);

        when(wifiEntry1.getKey()).thenReturn("KEY_1");

        when(mWifiPickerTracker.getConnectedWifiEntry()).thenReturn(wifiEntry1);

        mController.displayPreference(mScreen);

        final ArgumentCaptor<AccessPointPreference> captor = ArgumentCaptor.forClass(

                AccessPointPreference.class);



        final ArgumentCaptor<WifiEntryPreference> captor = ArgumentCaptor.forClass(

                WifiEntryPreference.class);



        final AccessPoint accessPoint2 = mock(AccessPoint.class);

        when(accessPoint1.isActive()).thenReturn(false);

        when(accessPoint2.isActive()).thenReturn(true);

        when(mWifiTracker.getAccessPoints()).thenReturn(Arrays.asList(accessPoint1, accessPoint2));

        final WifiEntry wifiEntry2 = mock(WifiEntry.class);

        when(wifiEntry1.getKey()).thenReturn("KEY_2");

        when(mWifiPickerTracker.getConnectedWifiEntry()).thenReturn(wifiEntry2);

        final int onUpdatedCountBefore = mOnChildUpdatedCount;

        mController.onAccessPointsChanged();

        mController.onWifiEntriesChanged();



        verify(mPreferenceCategory, times(2)).addPreference(captor.capture());

        final AccessPointPreference pref1 = captor.getAllValues().get(0);

        final AccessPointPreference pref2 = captor.getAllValues().get(1);

        assertThat(pref1.getAccessPoint()).isEqualTo(accessPoint1);

        assertThat(pref2.getAccessPoint()).isEqualTo(accessPoint2);

        final WifiEntryPreference pref1 = captor.getAllValues().get(0);

        final WifiEntryPreference pref2 = captor.getAllValues().get(1);

        assertThat(pref1.getWifiEntry()).isEqualTo(wifiEntry1);

        assertThat(pref2.getWifiEntry()).isEqualTo(wifiEntry2);

        verify(mPreferenceCategory).removePreference(eq(pref1));

        assertThat(mOnChildUpdatedCount).isEqualTo(onUpdatedCountBefore + 1);

    }