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

Revert "[Wi-Fi] Refactor WifiConnectionPreferenceController with WifiTrackerLib"

Browse Source 
This reverts commit ebf8ffd8fd.

Reason for revert: b/161659380

Bug: 161659380
Test: manual, observe threads after launching 'Network & internet'.
Change-Id: I28773eac40c6bf194e3410b829a1a7b744f79597
Merged-In: Id4901d632f7f4634461ebbbc096e36d348a33365
This commit is contained in:
Arc Wang
2020-07-21 01:59:35 +00:00
parent 1fafa1b738
commit 55bce77aea
2 changed files with 125 additions and 134 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -17,32 +17,22 @@
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.os.Handler; import android.util.FeatureFlagUtils;
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.WifiEntryPreference; import com.android.settingslib.wifi.AccessPoint;
import com.android.wifitrackerlib.WifiEntry; import com.android.settingslib.wifi.AccessPointPreference;
import com.android.wifitrackerlib.WifiPickerTracker; import com.android.settingslib.wifi.WifiTracker;
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.
/** /**
@@ -50,28 +40,21 @@ import java.time.ZoneOffset;
* 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
WifiPickerTracker.WifiPickerTrackerCallback { WifiTracker.WifiListener {
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;
@VisibleForTesting private WifiTracker mWifiTracker;
public WifiPickerTracker mWifiPickerTracker; private AccessPointPreference mPreference;
private WifiEntryPreference mPreference; private AccessPointPreference.UserBadgeCache mBadgeCache;
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
@@ -99,34 +82,16 @@ 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 mWifiPickerTracker.getConnectedWifiEntry() != null; return mWifiTracker.isConnected() && getCurrentAccessPoint() != null;
} }
@Override @Override
@@ -142,69 +107,88 @@ public class WifiConnectionPreferenceController extends AbstractPreferenceContro
update(); update();
} }
private void updatePreference(WifiEntry wifiEntry) { private AccessPoint getCurrentAccessPoint() {
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 (wifiEntry == null || mPrefContext == null) { if (accessPoint == 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);
mPreference = new WifiEntryPreference(mPrefContext, wifiEntry); if (FeatureFlagUtils.isEnabled(mPrefContext, FeatureFlagUtils.SETTINGS_WIFITRACKER2)) {
mPreference.setKey(KEY); mPreference.setOnPreferenceClickListener(pref -> {
mPreference.refresh(); Bundle args = new Bundle();
mPreference.setOrder(order); mPreference.getAccessPoint().saveWifiState(args);
mPreference.setOnPreferenceClickListener(pref -> { new SubSettingLauncher(mPrefContext)
final Bundle args = new Bundle(); .setTitleRes(R.string.pref_title_network_details)
args.putString(WifiNetworkDetailsFragment2.KEY_CHOSEN_WIFIENTRY_KEY, .setDestination(WifiNetworkDetailsFragment2.class.getName())
wifiEntry.getKey()); .setArguments(args)
new SubSettingLauncher(mPrefContext) .setSourceMetricsCategory(mMetricsCategory)
.setTitleRes(R.string.pref_title_network_details) .launch();
.setDestination(WifiNetworkDetailsFragment2.class.getName()) return true;
.setArguments(args) });
.setSourceMetricsCategory(mMetricsCategory) } else {
.launch(); mPreference.setOnPreferenceClickListener(pref -> {
return true; Bundle args = new Bundle();
}); mPreference.getAccessPoint().saveWifiState(args);
mPreferenceGroup.addPreference(mPreference); 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() { private void update() {
final WifiEntry connectedWifiEntry = mWifiPickerTracker.getConnectedWifiEntry(); AccessPoint connectedAccessPoint = null;
if (connectedWifiEntry == null) { if (mWifiTracker.isConnected()) {
connectedAccessPoint = getCurrentAccessPoint();
}
if (connectedAccessPoint == null) {
updatePreference(null); updatePreference(null);
} else { } else {
if (mPreference == null || !mPreference.getWifiEntry().equals(connectedWifiEntry)) { if (mPreference == null || !mPreference.getAccessPoint().equals(connectedAccessPoint)) {
updatePreference(connectedWifiEntry); updatePreference(connectedAccessPoint);
} 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() { public void onWifiStateChanged(int state) {
update();
}
/**
* Update the results when data changes.
*/
@Override
public void onWifiEntriesChanged() {
update(); update();
} }
@Override @Override
public void onNumSavedSubscriptionsChanged() { public void onConnectedChanged() {
// Do nothing. update();
} }
@Override @Override
public void onNumSavedNetworksChanged() { public void onAccessPointsChanged() {
// Do nothing. update();
} }
} }

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

@@ -29,15 +29,12 @@ 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.WifiEntryPreference; import com.android.settingslib.wifi.AccessPoint;
import com.android.wifitrackerlib.WifiEntry; import com.android.settingslib.wifi.AccessPointPreference;
import com.android.wifitrackerlib.WifiPickerTracker; import com.android.settingslib.wifi.WifiTracker;
import com.android.settingslib.wifi.WifiTrackerFactory;
import org.junit.Before; import org.junit.Before;
import org.junit.Test; import org.junit.Test;
@@ -48,12 +45,19 @@ 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
WifiPickerTracker mWifiPickerTracker; WifiTracker mWifiTracker;
@Mock @Mock
PreferenceScreen mScreen; PreferenceScreen mScreen;
@Mock @Mock
@@ -70,6 +74,7 @@ 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);
@@ -78,51 +83,49 @@ 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_noConnectedWifiEntry_availableIsFalse() { public void isAvailable_noWiFiConnection_availableIsFalse() {
when(mWifiPickerTracker.getConnectedWifiEntry()).thenReturn(null); when(mWifiTracker.isConnected()).thenReturn(false);
assertThat(mController.isAvailable()).isFalse(); assertThat(mController.isAvailable()).isFalse();
} }
@Test @Test
public void displayPreference_noConnectedWifiEntry_noPreferenceAdded() { public void displayPreference_noWiFiConnection_noPreferenceAdded() {
when(mWifiPickerTracker.getConnectedWifiEntry()).thenReturn(null); when(mWifiTracker.isConnected()).thenReturn(false);
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_hasConnectedWifiEntry_preferenceAdded() { public void displayPreference_hasWiFiConnection_preferenceAdded() {
final WifiEntry wifiEntry = mock(WifiEntry.class); when(mWifiTracker.isConnected()).thenReturn(true);
when(mWifiPickerTracker.getConnectedWifiEntry()).thenReturn(wifiEntry); final AccessPoint accessPoint = mock(AccessPoint.class);
when(accessPoint.isActive()).thenReturn(true);
when(mWifiTracker.getAccessPoints()).thenReturn(Arrays.asList(accessPoint));
mController.displayPreference(mScreen); mController.displayPreference(mScreen);
verify(mPreferenceCategory).addPreference(any(WifiEntryPreference.class)); verify(mPreferenceCategory).addPreference(any(AccessPointPreference.class));
} }
@Test @Test
public void onConnectedChanged_wifiBecameDisconnected_preferenceRemoved() { public void onConnectedChanged_wifiBecameDisconnected_preferenceRemoved() {
final WifiEntry wifiEntry = mock(WifiEntry.class); when(mWifiTracker.isConnected()).thenReturn(true);
when(mWifiPickerTracker.getConnectedWifiEntry()).thenReturn(wifiEntry); final AccessPoint accessPoint = mock(AccessPoint.class);
when(accessPoint.isActive()).thenReturn(true);
when(mWifiTracker.getAccessPoints()).thenReturn(Arrays.asList(accessPoint));
mController.displayPreference(mScreen); mController.displayPreference(mScreen);
final ArgumentCaptor<WifiEntryPreference> captor = ArgumentCaptor.forClass( final ArgumentCaptor<AccessPointPreference> captor = ArgumentCaptor.forClass(
WifiEntryPreference.class); AccessPointPreference.class);
verify(mPreferenceCategory).addPreference(captor.capture()); verify(mPreferenceCategory).addPreference(captor.capture());
final WifiEntryPreference pref = captor.getValue(); final AccessPointPreference pref = captor.getValue();
// Become disconnected. when(mWifiTracker.isConnected()).thenReturn(false);
when(mWifiPickerTracker.getConnectedWifiEntry()).thenReturn(null); when(mWifiTracker.getAccessPoints()).thenReturn(new ArrayList<>());
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);
} }
@@ -130,24 +133,28 @@ public class WifiConnectionPreferenceControllerTest {
@Test @Test
public void onAccessPointsChanged_wifiBecameConnectedToDifferentAP_preferenceReplaced() { public void onAccessPointsChanged_wifiBecameConnectedToDifferentAP_preferenceReplaced() {
final WifiEntry wifiEntry1 = mock(WifiEntry.class); when(mWifiTracker.isConnected()).thenReturn(true);
when(wifiEntry1.getKey()).thenReturn("KEY_1"); final AccessPoint accessPoint1 = mock(AccessPoint.class);
when(mWifiPickerTracker.getConnectedWifiEntry()).thenReturn(wifiEntry1);
mController.displayPreference(mScreen);
final ArgumentCaptor<WifiEntryPreference> captor = ArgumentCaptor.forClass(
WifiEntryPreference.class);
final WifiEntry wifiEntry2 = mock(WifiEntry.class); when(accessPoint1.isActive()).thenReturn(true);
when(wifiEntry1.getKey()).thenReturn("KEY_2"); when(mWifiTracker.getAccessPoints()).thenReturn(Arrays.asList(accessPoint1));
when(mWifiPickerTracker.getConnectedWifiEntry()).thenReturn(wifiEntry2); mController.displayPreference(mScreen);
final ArgumentCaptor<AccessPointPreference> captor = ArgumentCaptor.forClass(
AccessPointPreference.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 int onUpdatedCountBefore = mOnChildUpdatedCount; final int onUpdatedCountBefore = mOnChildUpdatedCount;
mController.onWifiEntriesChanged(); mController.onAccessPointsChanged();
verify(mPreferenceCategory, times(2)).addPreference(captor.capture()); verify(mPreferenceCategory, times(2)).addPreference(captor.capture());
final WifiEntryPreference pref1 = captor.getAllValues().get(0); final AccessPointPreference pref1 = captor.getAllValues().get(0);
final WifiEntryPreference pref2 = captor.getAllValues().get(1); final AccessPointPreference pref2 = captor.getAllValues().get(1);
assertThat(pref1.getWifiEntry()).isEqualTo(wifiEntry1); assertThat(pref1.getAccessPoint()).isEqualTo(accessPoint1);
assertThat(pref2.getWifiEntry()).isEqualTo(wifiEntry2); assertThat(pref2.getAccessPoint()).isEqualTo(accessPoint2);
verify(mPreferenceCategory).removePreference(eq(pref1)); verify(mPreferenceCategory).removePreference(eq(pref1));
assertThat(mOnChildUpdatedCount).isEqualTo(onUpdatedCountBefore + 1); assertThat(mOnChildUpdatedCount).isEqualTo(onUpdatedCountBefore + 1);
} }