PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "[Wi-Fi] Refactor WifiConnectionPreferenceController with WifiTrackerLib" into rvc-dev am: 50aeb48c56 am: 8fd2e35c3f

Browse Source 
Change-Id: I5ec1c240b57f8d0fd733929c6921abe251ac7d4f
This commit is contained in:
TreeHugger Robot
2020-03-27 15:16:41 +00:00
committed by Automerger Merge Worker
parent e8a683eea2 8fd2e35c3f
commit 16d8adb1fd
2 changed files with 133 additions and 124 deletions
Download Patch File Download Diff File Expand all files Collapse all files

162
src/com/android/settings/wifi/WifiConnectionPreferenceController.java
View File

@@ -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,88 +142,69 @@ 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,
R.drawable.ic_wifi_signal_0, false /* forSavedNetworks */);
mPreference.setKey(KEY);
mPreference.refresh();
mPreference.setOrder(order);
if (FeatureFlagUtils.isEnabled(mPrefContext, FeatureFlagUtils.SETTINGS_WIFITRACKER2)) { mPreference = new WifiEntryPreference(mPrefContext, wifiEntry);
mPreference.setOnPreferenceClickListener(pref -> { mPreference.setKey(KEY);
Bundle args = new Bundle(); mPreference.refresh();
mPreference.getAccessPoint().saveWifiState(args); mPreference.setOrder(order);
new SubSettingLauncher(mPrefContext) mPreference.setOnPreferenceClickListener(pref -> {
.setTitleRes(R.string.pref_title_network_details) final Bundle args = new Bundle();
.setDestination(WifiNetworkDetailsFragment2.class.getName()) args.putString(WifiNetworkDetailsFragment2.KEY_CHOSEN_WIFIENTRY_KEY,
.setArguments(args) wifiEntry.getKey());
.setSourceMetricsCategory(mMetricsCategory) new SubSettingLauncher(mPrefContext)
.launch(); .setTitleRes(R.string.pref_title_network_details)
return true; .setDestination(WifiNetworkDetailsFragment2.class.getName())
}); .setArguments(args)
} else { .setSourceMetricsCategory(mMetricsCategory)
mPreference.setOnPreferenceClickListener(pref -> { .launch();
Bundle args = new Bundle(); return true;
mPreference.getAccessPoint().saveWifiState(args); });
new SubSettingLauncher(mPrefContext) mPreferenceGroup.addPreference(mPreference);
.setTitleRes(R.string.pref_title_network_details)
.setDestination(WifiNetworkDetailsFragment.class.getName())
.setArguments(args)
.setSourceMetricsCategory(mMetricsCategory)
.launch();
return true;
});
}
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();
} }
} }
mUpdateListener.onChildrenUpdated(); mUpdateListener.onChildrenUpdated();
} }
/** Called when the state of Wifi has changed. */
@Override @Override
public void onWifiStateChanged(int state) { public void onWifiStateChanged() {
update();
}
/**
* Update the results when data changes.
*/
@Override
public void onWifiEntriesChanged() {
update(); update();
} }
@Override @Override
public void onConnectedChanged() { public void onNumSavedSubscriptionsChanged() {
update(); // Do nothing.
} }
@Override @Override
public void onAccessPointsChanged() { public void onNumSavedNetworksChanged() {
update(); // Do nothing.
} }
} }

95
tests/robotests/src/com/android/settings/network/WifiConnectionPreferenceControllerTest.java
View File

@@ -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 WifiEntry wifiEntry2 = mock(WifiEntry.class);
final AccessPoint accessPoint2 = mock(AccessPoint.class); when(wifiEntry1.getKey()).thenReturn("KEY_2");
when(accessPoint1.isActive()).thenReturn(false); when(mWifiPickerTracker.getConnectedWifiEntry()).thenReturn(wifiEntry2);
when(accessPoint2.isActive()).thenReturn(true);
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);
} }