1 /* 2 * Copyright (C) 2011 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.settings.wifi; 18 19 import android.content.Context; 20 import android.net.wifi.WifiInfo; 21 import android.net.wifi.WifiManager; 22 import android.os.Bundle; 23 import android.preference.CheckBoxPreference; 24 import android.preference.ListPreference; 25 import android.preference.Preference; 26 import android.preference.PreferenceScreen; 27 import android.provider.Settings; 28 import android.provider.Settings.Secure; 29 import android.text.TextUtils; 30 import android.util.Log; 31 import android.widget.Toast; 32 33 import com.android.settings.R; 34 import com.android.settings.SettingsPreferenceFragment; 35 import com.android.settings.Utils; 36 37 public class AdvancedWifiSettings extends SettingsPreferenceFragment 38 implements Preference.OnPreferenceChangeListener { 39 40 private static final String TAG = "AdvancedWifiSettings"; 41 private static final String KEY_MAC_ADDRESS = "mac_address"; 42 private static final String KEY_CURRENT_IP_ADDRESS = "current_ip_address"; 43 private static final String KEY_FREQUENCY_BAND = "frequency_band"; 44 private static final String KEY_NOTIFY_OPEN_NETWORKS = "notify_open_networks"; 45 private static final String KEY_SLEEP_POLICY = "sleep_policy"; 46 private static final String KEY_ENABLE_WIFI_WATCHDOG = "wifi_enable_watchdog_service"; 47 48 private WifiManager mWifiManager; 49 50 @Override 51 public void onCreate(Bundle savedInstanceState) { 52 super.onCreate(savedInstanceState); 53 addPreferencesFromResource(R.xml.wifi_advanced_settings); 54 } 55 56 @Override 57 public void onActivityCreated(Bundle savedInstanceState) { 58 super.onActivityCreated(savedInstanceState); 59 mWifiManager = (WifiManager) getSystemService(Context.WIFI_SERVICE); 60 } 61 62 @Override 63 public void onResume() { 64 super.onResume(); 65 initPreferences(); 66 refreshWifiInfo(); 67 } 68 69 private void initPreferences() { 70 CheckBoxPreference notifyOpenNetworks = 71 (CheckBoxPreference) findPreference(KEY_NOTIFY_OPEN_NETWORKS); 72 notifyOpenNetworks.setChecked(Secure.getInt(getContentResolver(), 73 Secure.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON, 0) == 1); 74 notifyOpenNetworks.setEnabled(mWifiManager.isWifiEnabled()); 75 76 CheckBoxPreference watchdogEnabled = 77 (CheckBoxPreference) findPreference(KEY_ENABLE_WIFI_WATCHDOG); 78 if (watchdogEnabled != null) { 79 watchdogEnabled.setChecked(Secure.getInt(getContentResolver(), 80 Secure.WIFI_WATCHDOG_ON, 1) == 1); 81 82 //TODO: Bring this back after changing watchdog behavior 83 getPreferenceScreen().removePreference(watchdogEnabled); 84 } 85 86 ListPreference frequencyPref = (ListPreference) findPreference(KEY_FREQUENCY_BAND); 87 88 if (mWifiManager.isDualBandSupported()) { 89 frequencyPref.setOnPreferenceChangeListener(this); 90 int value = mWifiManager.getFrequencyBand(); 91 if (value != -1) { 92 frequencyPref.setValue(String.valueOf(value)); 93 } else { 94 Log.e(TAG, "Failed to fetch frequency band"); 95 } 96 } else { 97 if (frequencyPref != null) { 98 // null if it has already been removed before resume 99 getPreferenceScreen().removePreference(frequencyPref); 100 } 101 } 102 103 ListPreference sleepPolicyPref = (ListPreference) findPreference(KEY_SLEEP_POLICY); 104 if (sleepPolicyPref != null) { 105 if (Utils.isWifiOnly(getActivity())) { 106 sleepPolicyPref.setEntries(R.array.wifi_sleep_policy_entries_wifi_only); 107 } 108 sleepPolicyPref.setOnPreferenceChangeListener(this); 109 int value = Settings.System.getInt(getContentResolver(), 110 Settings.System.WIFI_SLEEP_POLICY, 111 Settings.System.WIFI_SLEEP_POLICY_NEVER); 112 String stringValue = String.valueOf(value); 113 sleepPolicyPref.setValue(stringValue); 114 updateSleepPolicySummary(sleepPolicyPref, stringValue); 115 } 116 } 117 118 private void updateSleepPolicySummary(Preference sleepPolicyPref, String value) { 119 if (value != null) { 120 String[] values = getResources().getStringArray(R.array.wifi_sleep_policy_values); 121 final int summaryArrayResId = Utils.isWifiOnly(getActivity()) ? 122 R.array.wifi_sleep_policy_entries_wifi_only : R.array.wifi_sleep_policy_entries; 123 String[] summaries = getResources().getStringArray(summaryArrayResId); 124 for (int i = 0; i < values.length; i++) { 125 if (value.equals(values[i])) { 126 if (i < summaries.length) { 127 sleepPolicyPref.setSummary(summaries[i]); 128 return; 129 } 130 } 131 } 132 } 133 134 sleepPolicyPref.setSummary(""); 135 Log.e(TAG, "Invalid sleep policy value: " + value); 136 } 137 138 @Override 139 public boolean onPreferenceTreeClick(PreferenceScreen screen, Preference preference) { 140 String key = preference.getKey(); 141 142 if (KEY_NOTIFY_OPEN_NETWORKS.equals(key)) { 143 Secure.putInt(getContentResolver(), 144 Secure.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON, 145 ((CheckBoxPreference) preference).isChecked() ? 1 : 0); 146 } else if (KEY_ENABLE_WIFI_WATCHDOG.equals(key)) { 147 Secure.putInt(getContentResolver(), 148 Secure.WIFI_WATCHDOG_ON, 149 ((CheckBoxPreference) preference).isChecked() ? 1 : 0); 150 } else { 151 return super.onPreferenceTreeClick(screen, preference); 152 } 153 return true; 154 } 155 156 @Override 157 public boolean onPreferenceChange(Preference preference, Object newValue) { 158 String key = preference.getKey(); 159 160 if (KEY_FREQUENCY_BAND.equals(key)) { 161 try { 162 mWifiManager.setFrequencyBand(Integer.parseInt((String) newValue), true); 163 } catch (NumberFormatException e) { 164 Toast.makeText(getActivity(), R.string.wifi_setting_frequency_band_error, 165 Toast.LENGTH_SHORT).show(); 166 return false; 167 } 168 } 169 170 if (KEY_SLEEP_POLICY.equals(key)) { 171 try { 172 String stringValue = (String) newValue; 173 Settings.System.putInt(getContentResolver(), Settings.System.WIFI_SLEEP_POLICY, 174 Integer.parseInt(stringValue)); 175 updateSleepPolicySummary(preference, stringValue); 176 } catch (NumberFormatException e) { 177 Toast.makeText(getActivity(), R.string.wifi_setting_sleep_policy_error, 178 Toast.LENGTH_SHORT).show(); 179 return false; 180 } 181 } 182 183 return true; 184 } 185 186 private void refreshWifiInfo() { 187 WifiInfo wifiInfo = mWifiManager.getConnectionInfo(); 188 189 Preference wifiMacAddressPref = findPreference(KEY_MAC_ADDRESS); 190 String macAddress = wifiInfo == null ? null : wifiInfo.getMacAddress(); 191 wifiMacAddressPref.setSummary(!TextUtils.isEmpty(macAddress) ? macAddress 192 : getActivity().getString(R.string.status_unavailable)); 193 194 Preference wifiIpAddressPref = findPreference(KEY_CURRENT_IP_ADDRESS); 195 String ipAddress = Utils.getWifiIpAddresses(getActivity()); 196 wifiIpAddressPref.setSummary(ipAddress == null ? 197 getActivity().getString(R.string.status_unavailable) : ipAddress); 198 } 199 200 } 201
