Merge "[Wi-Fi] Refactor WifiConnectionPreferenceController with WifiTrackerLib" into rvc-dev (50aeb48c) · Commits · e / os / android_packages_apps_Settings

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

+90 −74

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

	import android.content.Context;		import android.content.Context;
			import android.net.ConnectivityManager;
			import android.net.NetworkScoreManager;
			import android.net.wifi.WifiManager;
	import android.os.Bundle;		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.PreferenceGroup;
	import androidx.preference.PreferenceScreen;		import androidx.preference.PreferenceScreen;

	import com.android.settings.R;		import com.android.settings.R;
	import com.android.settings.core.SubSettingLauncher;		import com.android.settings.core.SubSettingLauncher;
	import com.android.settings.wifi.details.WifiNetworkDetailsFragment;
	import com.android.settings.wifi.details2.WifiNetworkDetailsFragment2;		import com.android.settings.wifi.details2.WifiNetworkDetailsFragment2;
	import com.android.settingslib.core.AbstractPreferenceController;		import com.android.settingslib.core.AbstractPreferenceController;
	import com.android.settingslib.core.lifecycle.Lifecycle;		import com.android.settingslib.core.lifecycle.Lifecycle;
	import com.android.settingslib.wifi.AccessPoint;		import com.android.settingslib.wifi.WifiEntryPreference;
	import com.android.settingslib.wifi.AccessPointPreference;		import com.android.wifitrackerlib.WifiEntry;
	import com.android.settingslib.wifi.WifiTracker;		import com.android.wifitrackerlib.WifiPickerTracker;
	import com.android.settingslib.wifi.WifiTrackerFactory;
			import java.time.Clock;
			import java.time.ZoneOffset;

	// TODO(b/151133650): Replace AbstractPreferenceController with BasePreferenceController.		// 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.		* controller class when there is a wifi connection present.
	*/		*/
	public class WifiConnectionPreferenceController extends AbstractPreferenceController implements		public class WifiConnectionPreferenceController extends AbstractPreferenceController implements
	WifiTracker.WifiListener {		WifiPickerTracker.WifiPickerTrackerCallback {

	private static final String TAG = "WifiConnPrefCtrl";		private static final String TAG = "WifiConnPrefCtrl";

	private static final String KEY = "active_wifi_connection";		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 UpdateListener mUpdateListener;
	private Context mPrefContext;		private Context mPrefContext;
	private String mPreferenceGroupKey;		private String mPreferenceGroupKey;
	private PreferenceGroup mPreferenceGroup;		private PreferenceGroup mPreferenceGroup;
	private WifiTracker mWifiTracker;		@VisibleForTesting
	private AccessPointPreference mPreference;		public WifiPickerTracker mWifiPickerTracker;
	private AccessPointPreference.UserBadgeCache mBadgeCache;		private WifiEntryPreference mPreference;
	private int order;		private int order;
	private int mMetricsCategory;		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		* 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);		super(context);
	mUpdateListener = updateListener;		mUpdateListener = updateListener;
	mPreferenceGroupKey = preferenceGroupKey;		mPreferenceGroupKey = preferenceGroupKey;
	mWifiTracker = WifiTrackerFactory.create(context, this, lifecycle, true /* includeSaved */,
	true /* includeScans */);
	this.order = order;		this.order = order;
	mMetricsCategory = metricsCategory;		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		@Override
	public boolean isAvailable() {		public boolean isAvailable() {
	return mWifiTracker.isConnected() && getCurrentAccessPoint() != null;		return mWifiPickerTracker.getConnectedWifiEntry() != null;
	}		}

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

	private AccessPoint getCurrentAccessPoint() {		private void updatePreference(WifiEntry wifiEntry) {
	for (AccessPoint accessPoint : mWifiTracker.getAccessPoints()) {
	if (accessPoint.isActive()) {
	return accessPoint;
	}
	}
	return null;
	}

	private void updatePreference(AccessPoint accessPoint) {
	if (mPreference != null) {		if (mPreference != null) {
	mPreferenceGroup.removePreference(mPreference);		mPreferenceGroup.removePreference(mPreference);
	mPreference = null;		mPreference = null;
	}		}
	if (accessPoint == null) {		if (wifiEntry == null \|\| mPrefContext == null) {
	return;		return;
	}		}
	if (mPrefContext != null) {
	mPreference = new AccessPointPreference(accessPoint, mPrefContext, mBadgeCache,		mPreference = new WifiEntryPreference(mPrefContext, wifiEntry);
	R.drawable.ic_wifi_signal_0, false /* forSavedNetworks */);
	mPreference.setKey(KEY);		mPreference.setKey(KEY);
	mPreference.refresh();		mPreference.refresh();
	mPreference.setOrder(order);		mPreference.setOrder(order);

	if (FeatureFlagUtils.isEnabled(mPrefContext, FeatureFlagUtils.SETTINGS_WIFITRACKER2)) {
	mPreference.setOnPreferenceClickListener(pref -> {		mPreference.setOnPreferenceClickListener(pref -> {
	Bundle args = new Bundle();		final Bundle args = new Bundle();
	mPreference.getAccessPoint().saveWifiState(args);		args.putString(WifiNetworkDetailsFragment2.KEY_CHOSEN_WIFIENTRY_KEY,
			wifiEntry.getKey());
	new SubSettingLauncher(mPrefContext)		new SubSettingLauncher(mPrefContext)
	.setTitleRes(R.string.pref_title_network_details)		.setTitleRes(R.string.pref_title_network_details)
	.setDestination(WifiNetworkDetailsFragment2.class.getName())		.setDestination(WifiNetworkDetailsFragment2.class.getName())
	@@ -143,33 +167,16 @@ public class WifiConnectionPreferenceController extends AbstractPreferenceContro
	.launch();		.launch();
	return true;		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);		mPreferenceGroup.addPreference(mPreference);
	}		}
	}

	private void update() {		private void update() {
	AccessPoint connectedAccessPoint = null;		final WifiEntry connectedWifiEntry = mWifiPickerTracker.getConnectedWifiEntry();
	if (mWifiTracker.isConnected()) {		if (connectedWifiEntry == null) {
	connectedAccessPoint = getCurrentAccessPoint();
	}
	if (connectedAccessPoint == null) {
	updatePreference(null);		updatePreference(null);
	} else {		} else {
	if (mPreference == null \|\| !mPreference.getAccessPoint().equals(connectedAccessPoint)) {		if (mPreference == null \|\| !mPreference.getWifiEntry().equals(connectedWifiEntry)) {
	updatePreference(connectedAccessPoint);		updatePreference(connectedWifiEntry);
	} else if (mPreference != null) {		} else if (mPreference != null) {
	mPreference.refresh();		mPreference.refresh();
	}		}
	@@ -177,18 +184,27 @@ public class WifiConnectionPreferenceController extends AbstractPreferenceContro
	mUpdateListener.onChildrenUpdated();		mUpdateListener.onChildrenUpdated();
	}		}

			/** Called when the state of Wifi has changed. */
	@Override		@Override
	public void onWifiStateChanged(int state) {		public void onWifiStateChanged() {
	update();		update();
	}		}

			/**
			* Update the results when data changes.
			*/
	@Override		@Override
	public void onConnectedChanged() {		public void onWifiEntriesChanged() {
	update();		update();
	}		}

	@Override		@Override
	public void onAccessPointsChanged() {		public void onNumSavedSubscriptionsChanged() {
	update();		// Do nothing.
			}

			@Override
			public void onNumSavedNetworksChanged() {
			// Do nothing.
	}		}
	}		}

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

+44 −51

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

	import android.content.Context;		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.settings.wifi.WifiConnectionPreferenceController;
	import com.android.settingslib.core.lifecycle.Lifecycle;		import com.android.settingslib.core.lifecycle.Lifecycle;
	import com.android.settingslib.wifi.AccessPoint;		import com.android.settingslib.wifi.WifiEntryPreference;
	import com.android.settingslib.wifi.AccessPointPreference;		import com.android.wifitrackerlib.WifiEntry;
	import com.android.settingslib.wifi.WifiTracker;		import com.android.wifitrackerlib.WifiPickerTracker;
	import com.android.settingslib.wifi.WifiTrackerFactory;

	import org.junit.Before;		import org.junit.Before;
	import org.junit.Test;		import org.junit.Test;
	@@ -45,19 +48,12 @@ import org.mockito.MockitoAnnotations;
	import org.robolectric.RobolectricTestRunner;		import org.robolectric.RobolectricTestRunner;
	import org.robolectric.RuntimeEnvironment;		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)		@RunWith(RobolectricTestRunner.class)
	public class WifiConnectionPreferenceControllerTest {		public class WifiConnectionPreferenceControllerTest {
	private static final String KEY = "wifi_connection";		private static final String KEY = "wifi_connection";

	@Mock		@Mock
	WifiTracker mWifiTracker;		WifiPickerTracker mWifiPickerTracker;
	@Mock		@Mock
	PreferenceScreen mScreen;		PreferenceScreen mScreen;
	@Mock		@Mock
	@@ -74,7 +70,6 @@ public class WifiConnectionPreferenceControllerTest {
	public void setUp() {		public void setUp() {
	MockitoAnnotations.initMocks(this);		MockitoAnnotations.initMocks(this);
	mContext = spy(RuntimeEnvironment.application);		mContext = spy(RuntimeEnvironment.application);
	WifiTrackerFactory.setTestingWifiTracker(mWifiTracker);
	mLifecycleOwner = () -> mLifecycle;		mLifecycleOwner = () -> mLifecycle;
	mLifecycle = new Lifecycle(mLifecycleOwner);		mLifecycle = new Lifecycle(mLifecycleOwner);
	when(mScreen.findPreference(eq(KEY))).thenReturn(mPreferenceCategory);		when(mScreen.findPreference(eq(KEY))).thenReturn(mPreferenceCategory);
	@@ -83,49 +78,51 @@ public class WifiConnectionPreferenceControllerTest {

	mController = new WifiConnectionPreferenceController(mContext, mLifecycle, mUpdateListener,		mController = new WifiConnectionPreferenceController(mContext, mLifecycle, mUpdateListener,
	KEY, 0, 0);		KEY, 0, 0);
			mController.mWifiPickerTracker = mWifiPickerTracker;
	}		}

	@Test		@Test
	public void isAvailable_noWiFiConnection_availableIsFalse() {		public void isAvailable_noConnectedWifiEntry_availableIsFalse() {
	when(mWifiTracker.isConnected()).thenReturn(false);		when(mWifiPickerTracker.getConnectedWifiEntry()).thenReturn(null);

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

	@Test		@Test
	public void displayPreference_noWiFiConnection_noPreferenceAdded() {		public void displayPreference_noConnectedWifiEntry_noPreferenceAdded() {
	when(mWifiTracker.isConnected()).thenReturn(false);		when(mWifiPickerTracker.getConnectedWifiEntry()).thenReturn(null);
	when(mWifiTracker.getAccessPoints()).thenReturn(new ArrayList<>());
	mController.displayPreference(mScreen);		mController.displayPreference(mScreen);

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

	@Test		@Test
	public void displayPreference_hasWiFiConnection_preferenceAdded() {		public void displayPreference_hasConnectedWifiEntry_preferenceAdded() {
	when(mWifiTracker.isConnected()).thenReturn(true);		final WifiEntry wifiEntry = mock(WifiEntry.class);
	final AccessPoint accessPoint = mock(AccessPoint.class);		when(mWifiPickerTracker.getConnectedWifiEntry()).thenReturn(wifiEntry);
	when(accessPoint.isActive()).thenReturn(true);
	when(mWifiTracker.getAccessPoints()).thenReturn(Arrays.asList(accessPoint));
	mController.displayPreference(mScreen);		mController.displayPreference(mScreen);
	verify(mPreferenceCategory).addPreference(any(AccessPointPreference.class));		verify(mPreferenceCategory).addPreference(any(WifiEntryPreference.class));
	}		}

	@Test		@Test
	public void onConnectedChanged_wifiBecameDisconnected_preferenceRemoved() {		public void onConnectedChanged_wifiBecameDisconnected_preferenceRemoved() {
	when(mWifiTracker.isConnected()).thenReturn(true);		final WifiEntry wifiEntry = mock(WifiEntry.class);
	final AccessPoint accessPoint = mock(AccessPoint.class);		when(mWifiPickerTracker.getConnectedWifiEntry()).thenReturn(wifiEntry);

	when(accessPoint.isActive()).thenReturn(true);
	when(mWifiTracker.getAccessPoints()).thenReturn(Arrays.asList(accessPoint));
	mController.displayPreference(mScreen);		mController.displayPreference(mScreen);
	final ArgumentCaptor<AccessPointPreference> captor = ArgumentCaptor.forClass(		final ArgumentCaptor<WifiEntryPreference> captor = ArgumentCaptor.forClass(
	AccessPointPreference.class);		WifiEntryPreference.class);
	verify(mPreferenceCategory).addPreference(captor.capture());		verify(mPreferenceCategory).addPreference(captor.capture());
	final AccessPointPreference pref = captor.getValue();		final WifiEntryPreference pref = captor.getValue();

	when(mWifiTracker.isConnected()).thenReturn(false);		// Become disconnected.
	when(mWifiTracker.getAccessPoints()).thenReturn(new ArrayList<>());		when(mWifiPickerTracker.getConnectedWifiEntry()).thenReturn(null);
	final int onUpdatedCountBefore = mOnChildUpdatedCount;		final int onUpdatedCountBefore = mOnChildUpdatedCount;
	mController.onConnectedChanged();
			mController.onWifiStateChanged();

	verify(mPreferenceCategory).removePreference(pref);		verify(mPreferenceCategory).removePreference(pref);
	assertThat(mOnChildUpdatedCount).isEqualTo(onUpdatedCountBefore + 1);		assertThat(mOnChildUpdatedCount).isEqualTo(onUpdatedCountBefore + 1);
	}		}
	@@ -133,28 +130,24 @@ public class WifiConnectionPreferenceControllerTest {

	@Test		@Test
	public void onAccessPointsChanged_wifiBecameConnectedToDifferentAP_preferenceReplaced() {		public void onAccessPointsChanged_wifiBecameConnectedToDifferentAP_preferenceReplaced() {
	when(mWifiTracker.isConnected()).thenReturn(true);		final WifiEntry wifiEntry1 = mock(WifiEntry.class);
	final AccessPoint accessPoint1 = mock(AccessPoint.class);		when(wifiEntry1.getKey()).thenReturn("KEY_1");
			when(mWifiPickerTracker.getConnectedWifiEntry()).thenReturn(wifiEntry1);
	when(accessPoint1.isActive()).thenReturn(true);
	when(mWifiTracker.getAccessPoints()).thenReturn(Arrays.asList(accessPoint1));
	mController.displayPreference(mScreen);		mController.displayPreference(mScreen);
	final ArgumentCaptor<AccessPointPreference> captor = ArgumentCaptor.forClass(		final ArgumentCaptor<WifiEntryPreference> captor = ArgumentCaptor.forClass(
	AccessPointPreference.class);		WifiEntryPreference.class);


	final AccessPoint accessPoint2 = mock(AccessPoint.class);		final WifiEntry wifiEntry2 = mock(WifiEntry.class);
	when(accessPoint1.isActive()).thenReturn(false);		when(wifiEntry1.getKey()).thenReturn("KEY_2");
	when(accessPoint2.isActive()).thenReturn(true);		when(mWifiPickerTracker.getConnectedWifiEntry()).thenReturn(wifiEntry2);
	when(mWifiTracker.getAccessPoints()).thenReturn(Arrays.asList(accessPoint1, accessPoint2));
	final int onUpdatedCountBefore = mOnChildUpdatedCount;		final int onUpdatedCountBefore = mOnChildUpdatedCount;
	mController.onAccessPointsChanged();		mController.onWifiEntriesChanged();

	verify(mPreferenceCategory, times(2)).addPreference(captor.capture());		verify(mPreferenceCategory, times(2)).addPreference(captor.capture());
	final AccessPointPreference pref1 = captor.getAllValues().get(0);		final WifiEntryPreference pref1 = captor.getAllValues().get(0);
	final AccessPointPreference pref2 = captor.getAllValues().get(1);		final WifiEntryPreference pref2 = captor.getAllValues().get(1);
	assertThat(pref1.getAccessPoint()).isEqualTo(accessPoint1);		assertThat(pref1.getWifiEntry()).isEqualTo(wifiEntry1);
	assertThat(pref2.getAccessPoint()).isEqualTo(accessPoint2);		assertThat(pref2.getWifiEntry()).isEqualTo(wifiEntry2);
	verify(mPreferenceCategory).removePreference(eq(pref1));		verify(mPreferenceCategory).removePreference(eq(pref1));
	assertThat(mOnChildUpdatedCount).isEqualTo(onUpdatedCountBefore + 1);		assertThat(mOnChildUpdatedCount).isEqualTo(onUpdatedCountBefore + 1);
	}		}