Create configure Wi-Fi screen

Add a gear on Settings menu, and move a bunch of stuff from
overflow and advanced screen to there.  Also move add network
to be the last item in the list rather than in overflow.

Also fix WifiP2p breakage.

Change-Id: I5c84c25e5ba9224f77dcd988b0b2850ae6e71168
This commit is contained in:
Jason Monk
2015-12-04 09:36:36 -05:00
parent e1481ee90d
commit 0b4fdc49fb
8 changed files with 421 additions and 346 deletions

View File

@@ -0,0 +1,293 @@
/*
* Copyright (C) 2015 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.settings.wifi;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.NetworkScoreManager;
import android.net.NetworkScorerAppManager;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.Bundle;
import android.os.UserManager;
import android.provider.Settings;
import android.support.v14.preference.SwitchPreference;
import android.support.v7.preference.ListPreference;
import android.support.v7.preference.Preference;
import android.text.TextUtils;
import android.util.Log;
import android.widget.Toast;
import com.android.settings.AppListSwitchPreference;
import com.android.settings.InstrumentedFragment;
import com.android.settings.R;
import com.android.settings.SettingsPreferenceFragment;
import com.android.settings.Utils;
import java.util.Collection;
import java.util.List;
public class ConfigureWifiSettings extends SettingsPreferenceFragment
implements Preference.OnPreferenceChangeListener {
private static final String TAG = "ConfigureWifiSettings";
private static final String KEY_MAC_ADDRESS = "mac_address";
private static final String KEY_SAVED_NETWORKS = "saved_networks";
private static final String KEY_CURRENT_IP_ADDRESS = "current_ip_address";
private static final String KEY_FREQUENCY_BAND = "frequency_band";
private static final String KEY_NOTIFY_OPEN_NETWORKS = "notify_open_networks";
private static final String KEY_SLEEP_POLICY = "sleep_policy";
private static final String KEY_WIFI_ASSISTANT = "wifi_assistant";
private WifiManager mWifiManager;
private NetworkScoreManager mNetworkScoreManager;
private AppListSwitchPreference mWifiAssistantPreference;
private IntentFilter mFilter;
@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
addPreferencesFromResource(R.xml.wifi_configure_settings);
}
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
mWifiManager = (WifiManager) getSystemService(Context.WIFI_SERVICE);
mFilter = new IntentFilter();
mFilter.addAction(WifiManager.LINK_CONFIGURATION_CHANGED_ACTION);
mFilter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
mNetworkScoreManager =
(NetworkScoreManager) getSystemService(Context.NETWORK_SCORE_SERVICE);
}
@Override
public void onResume() {
super.onResume();
initPreferences();
getActivity().registerReceiver(mReceiver, mFilter);
refreshWifiInfo();
}
@Override
public void onPause() {
super.onPause();
getActivity().unregisterReceiver(mReceiver);
}
private void initPreferences() {
List<WifiConfiguration> configs = mWifiManager.getConfiguredNetworks();
if (configs == null || configs.size() == 0) {
removePreference(KEY_SAVED_NETWORKS);
}
SwitchPreference notifyOpenNetworks =
(SwitchPreference) findPreference(KEY_NOTIFY_OPEN_NETWORKS);
notifyOpenNetworks.setChecked(Settings.Global.getInt(getContentResolver(),
Settings.Global.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON, 0) == 1);
notifyOpenNetworks.setEnabled(mWifiManager.isWifiEnabled());
final Context context = getActivity();
mWifiAssistantPreference = (AppListSwitchPreference) findPreference(KEY_WIFI_ASSISTANT);
Collection<NetworkScorerAppManager.NetworkScorerAppData> scorers =
NetworkScorerAppManager.getAllValidScorers(context);
if (UserManager.get(context).isAdminUser() && !scorers.isEmpty()) {
mWifiAssistantPreference.setOnPreferenceChangeListener(this);
initWifiAssistantPreference(scorers);
} else if (mWifiAssistantPreference != null) {
getPreferenceScreen().removePreference(mWifiAssistantPreference);
}
ListPreference frequencyPref = (ListPreference) findPreference(KEY_FREQUENCY_BAND);
if (mWifiManager.isDualBandSupported()) {
frequencyPref.setOnPreferenceChangeListener(this);
int value = mWifiManager.getFrequencyBand();
if (value != -1) {
frequencyPref.setValue(String.valueOf(value));
updateFrequencyBandSummary(frequencyPref, value);
} else {
Log.e(TAG, "Failed to fetch frequency band");
}
} else {
if (frequencyPref != null) {
// null if it has already been removed before resume
getPreferenceScreen().removePreference(frequencyPref);
}
}
ListPreference sleepPolicyPref = (ListPreference) findPreference(KEY_SLEEP_POLICY);
if (sleepPolicyPref != null) {
if (Utils.isWifiOnly(context)) {
sleepPolicyPref.setEntries(R.array.wifi_sleep_policy_entries_wifi_only);
}
sleepPolicyPref.setOnPreferenceChangeListener(this);
int value = Settings.Global.getInt(getContentResolver(),
Settings.Global.WIFI_SLEEP_POLICY,
Settings.Global.WIFI_SLEEP_POLICY_NEVER);
String stringValue = String.valueOf(value);
sleepPolicyPref.setValue(stringValue);
updateSleepPolicySummary(sleepPolicyPref, stringValue);
}
}
private void updateSleepPolicySummary(Preference sleepPolicyPref, String value) {
if (value != null) {
String[] values = getResources().getStringArray(R.array.wifi_sleep_policy_values);
final int summaryArrayResId = Utils.isWifiOnly(getActivity()) ?
R.array.wifi_sleep_policy_entries_wifi_only : R.array.wifi_sleep_policy_entries;
String[] summaries = getResources().getStringArray(summaryArrayResId);
for (int i = 0; i < values.length; i++) {
if (value.equals(values[i])) {
if (i < summaries.length) {
sleepPolicyPref.setSummary(summaries[i]);
return;
}
}
}
}
sleepPolicyPref.setSummary("");
Log.e(TAG, "Invalid sleep policy value: " + value);
}
@Override
public boolean onPreferenceTreeClick(Preference preference) {
String key = preference.getKey();
if (KEY_NOTIFY_OPEN_NETWORKS.equals(key)) {
Settings.Global.putInt(getContentResolver(),
Settings.Global.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON,
((SwitchPreference) preference).isChecked() ? 1 : 0);
} else {
return super.onPreferenceTreeClick(preference);
}
return true;
}
@Override
public boolean onPreferenceChange(Preference preference, Object newValue) {
final Context context = getActivity();
String key = preference.getKey();
if (KEY_FREQUENCY_BAND.equals(key)) {
try {
int value = Integer.parseInt((String) newValue);
mWifiManager.setFrequencyBand(value, true);
updateFrequencyBandSummary(preference, value);
} catch (NumberFormatException e) {
Toast.makeText(context, R.string.wifi_setting_frequency_band_error,
Toast.LENGTH_SHORT).show();
return false;
}
} else if (KEY_WIFI_ASSISTANT.equals(key)) {
NetworkScorerAppManager.NetworkScorerAppData wifiAssistant =
NetworkScorerAppManager.getScorer(context, (String) newValue);
if (wifiAssistant == null) {
mNetworkScoreManager.setActiveScorer(null);
return true;
}
Intent intent = new Intent();
if (wifiAssistant.mConfigurationActivityClassName != null) {
// App has a custom configuration activity; launch that.
// This custom activity will be responsible for launching the system
// dialog.
intent.setClassName(wifiAssistant.mPackageName,
wifiAssistant.mConfigurationActivityClassName);
} else {
// Fall back on the system dialog.
intent.setAction(NetworkScoreManager.ACTION_CHANGE_ACTIVE);
intent.putExtra(NetworkScoreManager.EXTRA_PACKAGE_NAME,
wifiAssistant.mPackageName);
}
startActivity(intent);
// Don't update the preference widget state until the child activity returns.
// It will be updated in onResume after the activity finishes.
return false;
}
if (KEY_SLEEP_POLICY.equals(key)) {
try {
String stringValue = (String) newValue;
Settings.Global.putInt(getContentResolver(), Settings.Global.WIFI_SLEEP_POLICY,
Integer.parseInt(stringValue));
updateSleepPolicySummary(preference, stringValue);
} catch (NumberFormatException e) {
Toast.makeText(context, R.string.wifi_setting_sleep_policy_error,
Toast.LENGTH_SHORT).show();
return false;
}
}
return true;
}
private void refreshWifiInfo() {
final Context context = getActivity();
WifiInfo wifiInfo = mWifiManager.getConnectionInfo();
Preference wifiMacAddressPref = findPreference(KEY_MAC_ADDRESS);
String macAddress = wifiInfo == null ? null : wifiInfo.getMacAddress();
wifiMacAddressPref.setSummary(!TextUtils.isEmpty(macAddress) ? macAddress
: context.getString(R.string.status_unavailable));
wifiMacAddressPref.setSelectable(false);
Preference wifiIpAddressPref = findPreference(KEY_CURRENT_IP_ADDRESS);
String ipAddress = Utils.getWifiIpAddresses(context);
wifiIpAddressPref.setSummary(ipAddress == null ?
context.getString(R.string.status_unavailable) : ipAddress);
wifiIpAddressPref.setSelectable(false);
}
private void updateFrequencyBandSummary(Preference frequencyBandPref, int index) {
String[] summaries = getResources().getStringArray(R.array.wifi_frequency_band_entries);
frequencyBandPref.setSummary(summaries[index]);
}
private void initWifiAssistantPreference(
Collection<NetworkScorerAppManager.NetworkScorerAppData> scorers) {
int count = scorers.size();
String[] packageNames = new String[count];
int i = 0;
for (NetworkScorerAppManager.NetworkScorerAppData scorer : scorers) {
packageNames[i] = scorer.mPackageName;
i++;
}
mWifiAssistantPreference.setPackageNames(packageNames,
mNetworkScoreManager.getActiveScorerPackage());
}
@Override
protected int getMetricsCategory() {
return InstrumentedFragment.CONFIGURE_WIFI;
}
private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if (action.equals(WifiManager.LINK_CONFIGURATION_CHANGED_ACTION) ||
action.equals(WifiManager.NETWORK_STATE_CHANGED_ACTION)) {
refreshWifiInfo();
}
}
};
}