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

[Wi-Fi] Apply WifiTrackerLib objects in wifi/dpp/WifiNetworkListFragment

Browse Source 
Bug: 152571756
Bug: 145100890
Test: make RunSettingsRoboTests ROBOTEST_FILTER=WifiNetworkListFragmentTest
Change-Id: I2136b452da4a3008f493c46c8ed14b311cfc9fdd
This commit is contained in:
Arc Wang
2020-05-07 10:41:54 +08:00
parent 757982509e
commit e46081819d
6 changed files with 256 additions and 375 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
src/com/android/settings/wifi/dpp/WifiDppConfiguratorActivity.java
View File

@@ -88,9 +88,6 @@ public class WifiDppConfiguratorActivity extends WifiDppBaseActivity implements
*/
private int[] mWifiDppRemoteBandSupport;
/** Secret extra that allows fake networks to show in UI for testing purposes */
private boolean mIsTest;
@Override
public int getMetricsCategory() {
return SettingsEnums.SETTINGS_WIFI_DPP_CONFIGURATOR;
@@ -149,7 +146,6 @@ public class WifiDppConfiguratorActivity extends WifiDppBaseActivity implements
case Settings.ACTION_PROCESS_WIFI_EASY_CONNECT_URI:
final Uri uri = intent.getData();
final String uriString = (uri == null) ? null : uri.toString();
mIsTest = intent.getBooleanExtra(WifiDppUtils.EXTRA_TEST, false);
mWifiDppQrCode = WifiQrCode.getValidWifiDppQrCodeOrNull(uriString);
mWifiDppRemoteBandSupport = intent.getIntArrayExtra(
Settings.EXTRA_EASY_CONNECT_BAND_LIST); // returns null if none
@@ -239,11 +235,6 @@ public class WifiDppConfiguratorActivity extends WifiDppBaseActivity implements
if (fragment == null) {
fragment = new WifiDppChooseSavedWifiNetworkFragment();
if (mIsTest) {
Bundle bundle = new Bundle();
bundle.putBoolean(WifiDppUtils.EXTRA_TEST, true);
fragment.setArguments(bundle);
}
} else {
if (fragment.isVisible()) {
return;

4
src/com/android/settings/wifi/dpp/WifiDppUtils.java
View File

@@ -83,10 +83,6 @@ public class WifiDppUtils {
/** The data to recognize if it's a Wi-Fi hotspot for configuration */
static final String EXTRA_IS_HOTSPOT = "isHotspot";
/** Used by {@link android.provider.Settings#ACTION_PROCESS_WIFI_EASY_CONNECT_URI} to
* indicate test mode UI should be shown. Test UI does not make API calls. Value is a boolean.*/
static final String EXTRA_TEST = "test";
/**
* Default status code for Easy Connect
*/

6
src/com/android/settings/wifi/dpp/WifiNetworkConfig.java
View File

@@ -48,6 +48,9 @@ public class WifiNetworkConfig {
static final String FAKE_PASSWORD = "password";
private static final String TAG = "WifiNetworkConfig";
// Security from WifiNetworkListFragment/WifiTrackerLib may be WPA3.
static final String SECURITY_WPA3 = "WPA3";
private String mSecurity;
private String mSsid;
private String mPreSharedKey;
@@ -59,6 +62,9 @@ public class WifiNetworkConfig {
WifiNetworkConfig(String security, String ssid, String preSharedKey,
boolean hiddenSsid, int networkId, boolean isHotspot) {
mSecurity = security;
if (TextUtils.equals(mSecurity, SECURITY_WPA3)) {
mSecurity = SECURITY_SAE;
}
mSsid = ssid;
mPreSharedKey = preSharedKey;
mHiddenSsid = hiddenSsid;

301
src/com/android/settings/wifi/dpp/WifiNetworkListFragment.java
View File

@@ -20,13 +20,20 @@ import android.app.Activity;
import android.app.settings.SettingsEnums;
import android.content.Context;
import android.content.Intent;
import android.net.ConnectivityManager;
import android.net.NetworkScoreManager;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiManager;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
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 android.widget.Toast;
import androidx.annotation.VisibleForTesting;
import androidx.preference.Preference;
import androidx.preference.PreferenceCategory;
@@ -34,47 +41,63 @@ import com.android.settings.R;
import com.android.settings.SettingsPreferenceFragment;
import com.android.settings.core.SubSettingLauncher;
import com.android.settings.wifi.AddNetworkFragment;
import com.android.settingslib.wifi.AccessPoint;
import com.android.settingslib.wifi.AccessPointPreference;
import com.android.settingslib.wifi.WifiSavedConfigUtils;
import com.android.settingslib.wifi.WifiTracker;
import com.android.settingslib.wifi.WifiTrackerFactory;
import com.android.settingslib.wifi.WifiEntryPreference;
import com.android.wifitrackerlib.SavedNetworkTracker;
import com.android.wifitrackerlib.WifiEntry;
import java.time.Clock;
import java.time.ZoneOffset;
import java.util.List;
import java.util.stream.Collectors;
public class WifiNetworkListFragment extends SettingsPreferenceFragment implements
WifiTracker.WifiListener, AccessPoint.AccessPointListener {
SavedNetworkTracker.SavedNetworkTrackerCallback, Preference.OnPreferenceClickListener {
private static final String TAG = "WifiNetworkListFragment";
private static final String WIFI_CONFIG_KEY = "wifi_config_key";
@VisibleForTesting static final String WIFI_CONFIG_KEY = "wifi_config_key";
private static final String PREF_KEY_ACCESS_POINTS = "access_points";
private static final int ADD_NETWORK_REQUEST = 1;
@VisibleForTesting
static final int ADD_NETWORK_REQUEST = 1;
private PreferenceCategory mAccessPointsPreferenceCategory;
private AccessPointPreference.UserBadgeCache mUserBadgeCache;
private Preference mAddPreference;
// Only shows up if mIsTest == true
private Preference mFakeNetworkPreference;
@VisibleForTesting PreferenceCategory mPreferenceGroup;
@VisibleForTesting Preference mAddPreference;
private WifiManager mWifiManager;
private WifiTracker mWifiTracker;
@VisibleForTesting WifiManager mWifiManager;
private WifiManager.ActionListener mSaveListener;
private boolean mIsTest;
// Max age of tracked WifiEntries
private static final long MAX_SCAN_AGE_MILLIS = 15_000;
// Interval between initiating SavedNetworkTracker scans
private static final long SCAN_INTERVAL_MILLIS = 10_000;
@VisibleForTesting SavedNetworkTracker mSavedNetworkTracker;
private HandlerThread mWorkerThread;
// Container Activity must implement this interface
public interface OnChooseNetworkListener {
void onChooseNetwork(WifiNetworkConfig wifiNetworkConfig);
}
private OnChooseNetworkListener mOnChooseNetworkListener;
@VisibleForTesting OnChooseNetworkListener mOnChooseNetworkListener;
@Override
public int getMetricsCategory() {
return SettingsEnums.SETTINGS_WIFI_DPP_CONFIGURATOR;
}
private static class DisableUnreachableWifiEntryPreference extends WifiEntryPreference {
DisableUnreachableWifiEntryPreference(Context context, WifiEntry entry) {
super(context, entry);
}
@Override
public void onUpdated() {
super.onUpdated();
this.setEnabled(getWifiEntry().getLevel() != WifiEntry.WIFI_LEVEL_UNREACHABLE);
}
}
@Override
public void onAttach(Context context) {
super.onAttach(context);
@@ -94,14 +117,8 @@ public class WifiNetworkListFragment extends SettingsPreferenceFragment implemen
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
mWifiTracker = WifiTrackerFactory.create(getActivity(), this,
getSettingsLifecycle(), /* includeSaved */true, /* includeScans */ true);
mWifiManager = mWifiTracker.getManager();
final Bundle args = getArguments();
if (args != null) {
mIsTest = args.getBoolean(WifiDppUtils.EXTRA_TEST, false);
}
final Context context = getContext();
mWifiManager = context.getSystemService(WifiManager.class);
mSaveListener = new WifiManager.ActionListener() {
@Override
@@ -111,25 +128,45 @@ public class WifiNetworkListFragment extends SettingsPreferenceFragment implemen
@Override
public void onFailure(int reason) {
Activity activity = getActivity();
if (activity != null) {
Toast.makeText(activity,
R.string.wifi_failed_save_message,
final Activity activity = getActivity();
if (activity != null && !activity.isFinishing()) {
Toast.makeText(activity, R.string.wifi_failed_save_message,
Toast.LENGTH_SHORT).show();
}
}
};
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();
}
};
mSavedNetworkTracker = new SavedNetworkTracker(getSettingsLifecycle(), 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 void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
if (requestCode == ADD_NETWORK_REQUEST) {
if (resultCode == Activity.RESULT_OK) {
handleAddNetworkSubmitEvent(data);
if (requestCode == ADD_NETWORK_REQUEST && resultCode == Activity.RESULT_OK) {
final WifiConfiguration wifiConfiguration = data.getParcelableExtra(WIFI_CONFIG_KEY);
if (wifiConfiguration != null) {
mWifiManager.save(wifiConfiguration, mSaveListener);
}
mWifiTracker.resumeScanning();
}
}
@@ -137,203 +174,81 @@ public class WifiNetworkListFragment extends SettingsPreferenceFragment implemen
public void onCreatePreferences(Bundle savedInstanceState, String rootKey) {
addPreferencesFromResource(R.xml.wifi_dpp_network_list);
mAccessPointsPreferenceCategory = findPreference(PREF_KEY_ACCESS_POINTS);
mFakeNetworkPreference = new Preference(getPrefContext());
mFakeNetworkPreference.setIcon(R.drawable.ic_wifi_signal_0);
mFakeNetworkPreference.setKey("fake_key");
mFakeNetworkPreference.setTitle("fake network");
mPreferenceGroup = findPreference(PREF_KEY_ACCESS_POINTS);
mAddPreference = new Preference(getPrefContext());
mAddPreference.setIcon(R.drawable.ic_add_24dp);
mAddPreference.setTitle(R.string.wifi_add_network);
mUserBadgeCache = new AccessPointPreference.UserBadgeCache(getPackageManager());
mAddPreference.setOnPreferenceClickListener(this);
}
/** Called when the state of Wifi has changed. */
@Override
public void onWifiStateChanged(int state) {
final int wifiState = mWifiManager.getWifiState();
switch (wifiState) {
case WifiManager.WIFI_STATE_ENABLED:
updateAccessPointPreferences();
break;
public void onSavedWifiEntriesChanged() {
final List<WifiEntry> savedWifiEntries = mSavedNetworkTracker.getSavedWifiEntries().stream()
.filter(entry -> isValidForDppConfiguration(entry))
.collect(Collectors.toList());
case WifiManager.WIFI_STATE_ENABLING:
case WifiManager.WIFI_STATE_DISABLING:
removeAccessPointPreferences();
break;
int index = 0;
mPreferenceGroup.removeAll();
for (WifiEntry savedEntry : savedWifiEntries) {
final DisableUnreachableWifiEntryPreference preference =
new DisableUnreachableWifiEntryPreference(getContext(), savedEntry);
preference.setOnPreferenceClickListener(this);
preference.setEnabled(savedEntry.getLevel() != WifiEntry.WIFI_LEVEL_UNREACHABLE);
preference.setOrder(index++);
mPreferenceGroup.addPreference(preference);
}
mAddPreference.setOrder(index);
mPreferenceGroup.addPreference(mAddPreference);
}
/** Called when the connection state of wifi has changed. */
@Override
public void onConnectedChanged() {
public void onSubscriptionWifiEntriesChanged() {
// Do nothing.
}
/**
* Called to indicate the list of AccessPoints has been updated and
* getAccessPoints should be called to get the latest information.
*/
@Override
public void onAccessPointsChanged() {
updateAccessPointPreferences();
public void onWifiStateChanged() {
// Do nothing.
}
@Override
public void onAccessPointChanged(final AccessPoint accessPoint) {
Log.d(TAG, "onAccessPointChanged (singular) callback initiated");
View view = getView();
if (view != null) {
view.post(() -> {
final Object tag = accessPoint.getTag();
if (tag != null) {
((AccessPointPreference) tag).refresh();
}
});
}
}
@Override
public void onLevelChanged(AccessPoint accessPoint) {
((AccessPointPreference) accessPoint.getTag()).onLevelChanged();
}
@Override
public boolean onPreferenceTreeClick(Preference preference) {
if (preference instanceof AccessPointPreference) {
final AccessPoint selectedAccessPoint =
((AccessPointPreference) preference).getAccessPoint();
if (selectedAccessPoint == null) {
return false;
}
public boolean onPreferenceClick(Preference preference) {
if (preference instanceof WifiEntryPreference) {
final WifiEntry selectedWifiEntry = ((WifiEntryPreference) preference).getWifiEntry();
// Launch WifiDppAddDeviceFragment to start DPP in Configurator-Initiator role.
final WifiConfiguration wifiConfig = selectedAccessPoint.getConfig();
final WifiConfiguration wifiConfig = selectedWifiEntry.getWifiConfiguration();
if (wifiConfig == null) {
throw new IllegalArgumentException("Invalid access point");
}
final WifiNetworkConfig networkConfig = WifiNetworkConfig.getValidConfigOrNull(
selectedAccessPoint.getSecurityString(/* concise */ true),
selectedWifiEntry.getSecurityString(/* concise */ true),
wifiConfig.getPrintableSsid(), wifiConfig.preSharedKey, wifiConfig.hiddenSSID,
wifiConfig.networkId, /* isHotspot */ false);
if (mOnChooseNetworkListener != null) {
mOnChooseNetworkListener.onChooseNetwork(networkConfig);
}
} else if (preference == mAddPreference) {
launchAddNetworkFragment();
} else if (preference == mFakeNetworkPreference) {
if (mOnChooseNetworkListener != null) {
mOnChooseNetworkListener.onChooseNetwork(
new WifiNetworkConfig(
WifiQrCode.SECURITY_WPA_PSK,
/* ssid */ WifiNetworkConfig.FAKE_SSID,
/* preSharedKey */ WifiNetworkConfig.FAKE_PASSWORD,
/* hiddenSsid */ true,
/* networkId */ WifiConfiguration.INVALID_NETWORK_ID,
/* isHotspot*/ false));
}
new SubSettingLauncher(getContext())
.setTitleRes(R.string.wifi_add_network)
.setDestination(AddNetworkFragment.class.getName())
.setSourceMetricsCategory(getMetricsCategory())
.setResultListener(this, ADD_NETWORK_REQUEST)
.launch();
} else {
return super.onPreferenceTreeClick(preference);
}
return true;
}
private void handleAddNetworkSubmitEvent(Intent data) {
final WifiConfiguration wifiConfiguration = data.getParcelableExtra(WIFI_CONFIG_KEY);
if (wifiConfiguration != null) {
mWifiManager.save(wifiConfiguration, mSaveListener);
}
}
private boolean isValidForDppConfiguration(AccessPoint accessPoint) {
final int security = accessPoint.getSecurity();
private boolean isValidForDppConfiguration(WifiEntry wifiEntry) {
final int security = wifiEntry.getSecurity();
// DPP 1.0 only support PSK and SAE.
return security == AccessPoint.SECURITY_PSK || security == AccessPoint.SECURITY_SAE;
}
private void launchAddNetworkFragment() {
new SubSettingLauncher(getContext())
.setTitleRes(R.string.wifi_add_network)
.setDestination(AddNetworkFragment.class.getName())
.setSourceMetricsCategory(getMetricsCategory())
.setResultListener(this, ADD_NETWORK_REQUEST)
.launch();
}
private void removeAccessPointPreferences() {
mAccessPointsPreferenceCategory.removeAll();
mAccessPointsPreferenceCategory.setVisible(false);
}
private void updateAccessPointPreferences() {
// in case state has changed
if (!mWifiManager.isWifiEnabled()) {
return;
}
List<AccessPoint> savedAccessPoints =
WifiSavedConfigUtils.getAllConfigs(getContext(), mWifiManager);
savedAccessPoints = savedAccessPoints.stream()
.filter(accessPoint -> isValidForDppConfiguration(accessPoint))
.map(accessPoint -> getScannedAccessPointIfAvailable(accessPoint))
.sorted((ap1, ap2) -> {
// orders reachable Wi-Fi networks on top
if (ap1.isReachable() && !ap2.isReachable()) {
return -1;
} else if (!ap1.isReachable() && ap2.isReachable()) {
return 1;
}
String ap1Title = nullToEmpty(ap1.getTitle());
String ap2Title = nullToEmpty(ap2.getTitle());
return ap1Title.compareToIgnoreCase(ap2Title);
}).collect(Collectors.toList());
int index = 0;
mAccessPointsPreferenceCategory.removeAll();
for (AccessPoint savedAccessPoint : savedAccessPoints) {
final AccessPointPreference preference =
createAccessPointPreference(savedAccessPoint);
preference.setOrder(index++);
preference.setEnabled(savedAccessPoint.isReachable());
savedAccessPoint.setListener(this);
preference.refresh();
mAccessPointsPreferenceCategory.addPreference(preference);
}
mAddPreference.setOrder(index);
mAccessPointsPreferenceCategory.addPreference(mAddPreference);
if (mIsTest) {
mAccessPointsPreferenceCategory.addPreference(mFakeNetworkPreference);
}
}
private String nullToEmpty(String string) {
return (string == null) ? "" : string;
}
// Replaces with an AccessPoint from scanned result for signal information
private AccessPoint getScannedAccessPointIfAvailable(AccessPoint savedAccessPoint) {
final List<AccessPoint> scannedAccessPoints = mWifiTracker.getAccessPoints();
final WifiConfiguration savedWifiConfiguration = savedAccessPoint.getConfig();
for (AccessPoint scannedAccessPoint : scannedAccessPoints) {
if (scannedAccessPoint.matches(savedWifiConfiguration)) {
return scannedAccessPoint;
}
}
return savedAccessPoint;
}
private AccessPointPreference createAccessPointPreference(AccessPoint accessPoint) {
return new AccessPointPreference(accessPoint, getPrefContext(), mUserBadgeCache,
R.drawable.ic_wifi_signal_0, /* forSavedNetworks */ false);
return security == WifiEntry.SECURITY_PSK || security == WifiEntry.SECURITY_SAE;
}
}