399 lines
14 KiB
Java
399 lines
14 KiB
Java
/*
|
|
* Copyright (C) 2010 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.Context;
|
|
import android.net.NetworkInfo.DetailedState;
|
|
import android.net.wifi.ScanResult;
|
|
import android.net.wifi.WifiConfiguration;
|
|
import android.net.wifi.WifiConfiguration.KeyMgmt;
|
|
import android.net.wifi.WifiInfo;
|
|
import android.net.wifi.WifiManager;
|
|
import android.os.Bundle;
|
|
import android.preference.Preference;
|
|
import android.util.Log;
|
|
import android.view.View;
|
|
import android.widget.ImageView;
|
|
|
|
import com.android.settings.R;
|
|
|
|
class AccessPoint extends Preference {
|
|
static final String TAG = "Settings.AccessPoint";
|
|
|
|
private static final String KEY_DETAILEDSTATE = "key_detailedstate";
|
|
private static final String KEY_WIFIINFO = "key_wifiinfo";
|
|
private static final String KEY_SCANRESULT = "key_scanresult";
|
|
private static final String KEY_CONFIG = "key_config";
|
|
|
|
private static final int[] STATE_SECURED = {
|
|
R.attr.state_encrypted
|
|
};
|
|
private static final int[] STATE_NONE = {};
|
|
|
|
/** These values are matched in string arrays -- changes must be kept in sync */
|
|
static final int SECURITY_NONE = 0;
|
|
static final int SECURITY_WEP = 1;
|
|
static final int SECURITY_PSK = 2;
|
|
static final int SECURITY_EAP = 3;
|
|
|
|
enum PskType {
|
|
UNKNOWN,
|
|
WPA,
|
|
WPA2,
|
|
WPA_WPA2
|
|
}
|
|
|
|
String ssid;
|
|
String bssid;
|
|
int security;
|
|
int networkId;
|
|
boolean wpsAvailable = false;
|
|
|
|
PskType pskType = PskType.UNKNOWN;
|
|
|
|
private WifiConfiguration mConfig;
|
|
/* package */ScanResult mScanResult;
|
|
|
|
private int mRssi;
|
|
private WifiInfo mInfo;
|
|
private DetailedState mState;
|
|
|
|
static int getSecurity(WifiConfiguration config) {
|
|
if (config.allowedKeyManagement.get(KeyMgmt.WPA_PSK)) {
|
|
return SECURITY_PSK;
|
|
}
|
|
if (config.allowedKeyManagement.get(KeyMgmt.WPA_EAP) ||
|
|
config.allowedKeyManagement.get(KeyMgmt.IEEE8021X)) {
|
|
return SECURITY_EAP;
|
|
}
|
|
return (config.wepKeys[0] != null) ? SECURITY_WEP : SECURITY_NONE;
|
|
}
|
|
|
|
private static int getSecurity(ScanResult result) {
|
|
if (result.capabilities.contains("WEP")) {
|
|
return SECURITY_WEP;
|
|
} else if (result.capabilities.contains("PSK")) {
|
|
return SECURITY_PSK;
|
|
} else if (result.capabilities.contains("EAP")) {
|
|
return SECURITY_EAP;
|
|
}
|
|
return SECURITY_NONE;
|
|
}
|
|
|
|
public String getSecurityString(boolean concise) {
|
|
Context context = getContext();
|
|
switch(security) {
|
|
case SECURITY_EAP:
|
|
return concise ? context.getString(R.string.wifi_security_short_eap) :
|
|
context.getString(R.string.wifi_security_eap);
|
|
case SECURITY_PSK:
|
|
switch (pskType) {
|
|
case WPA:
|
|
return concise ? context.getString(R.string.wifi_security_short_wpa) :
|
|
context.getString(R.string.wifi_security_wpa);
|
|
case WPA2:
|
|
return concise ? context.getString(R.string.wifi_security_short_wpa2) :
|
|
context.getString(R.string.wifi_security_wpa2);
|
|
case WPA_WPA2:
|
|
return concise ? context.getString(R.string.wifi_security_short_wpa_wpa2) :
|
|
context.getString(R.string.wifi_security_wpa_wpa2);
|
|
case UNKNOWN:
|
|
default:
|
|
return concise ? context.getString(R.string.wifi_security_short_psk_generic)
|
|
: context.getString(R.string.wifi_security_psk_generic);
|
|
}
|
|
case SECURITY_WEP:
|
|
return concise ? context.getString(R.string.wifi_security_short_wep) :
|
|
context.getString(R.string.wifi_security_wep);
|
|
case SECURITY_NONE:
|
|
default:
|
|
return concise ? "" : context.getString(R.string.wifi_security_none);
|
|
}
|
|
}
|
|
|
|
private static PskType getPskType(ScanResult result) {
|
|
boolean wpa = result.capabilities.contains("WPA-PSK");
|
|
boolean wpa2 = result.capabilities.contains("WPA2-PSK");
|
|
if (wpa2 && wpa) {
|
|
return PskType.WPA_WPA2;
|
|
} else if (wpa2) {
|
|
return PskType.WPA2;
|
|
} else if (wpa) {
|
|
return PskType.WPA;
|
|
} else {
|
|
Log.w(TAG, "Received abnormal flag string: " + result.capabilities);
|
|
return PskType.UNKNOWN;
|
|
}
|
|
}
|
|
|
|
AccessPoint(Context context, WifiConfiguration config) {
|
|
super(context);
|
|
setWidgetLayoutResource(R.layout.preference_widget_wifi_signal);
|
|
loadConfig(config);
|
|
refresh();
|
|
}
|
|
|
|
AccessPoint(Context context, ScanResult result) {
|
|
super(context);
|
|
setWidgetLayoutResource(R.layout.preference_widget_wifi_signal);
|
|
loadResult(result);
|
|
refresh();
|
|
}
|
|
|
|
AccessPoint(Context context, Bundle savedState) {
|
|
super(context);
|
|
setWidgetLayoutResource(R.layout.preference_widget_wifi_signal);
|
|
|
|
mConfig = savedState.getParcelable(KEY_CONFIG);
|
|
if (mConfig != null) {
|
|
loadConfig(mConfig);
|
|
}
|
|
mScanResult = (ScanResult) savedState.getParcelable(KEY_SCANRESULT);
|
|
if (mScanResult != null) {
|
|
loadResult(mScanResult);
|
|
}
|
|
mInfo = (WifiInfo) savedState.getParcelable(KEY_WIFIINFO);
|
|
if (savedState.containsKey(KEY_DETAILEDSTATE)) {
|
|
mState = DetailedState.valueOf(savedState.getString(KEY_DETAILEDSTATE));
|
|
}
|
|
update(mInfo, mState);
|
|
}
|
|
|
|
public void saveWifiState(Bundle savedState) {
|
|
savedState.putParcelable(KEY_CONFIG, mConfig);
|
|
savedState.putParcelable(KEY_SCANRESULT, mScanResult);
|
|
savedState.putParcelable(KEY_WIFIINFO, mInfo);
|
|
if (mState != null) {
|
|
savedState.putString(KEY_DETAILEDSTATE, mState.toString());
|
|
}
|
|
}
|
|
|
|
private void loadConfig(WifiConfiguration config) {
|
|
ssid = (config.SSID == null ? "" : removeDoubleQuotes(config.SSID));
|
|
bssid = config.BSSID;
|
|
security = getSecurity(config);
|
|
networkId = config.networkId;
|
|
mRssi = Integer.MAX_VALUE;
|
|
mConfig = config;
|
|
}
|
|
|
|
private void loadResult(ScanResult result) {
|
|
ssid = result.SSID;
|
|
bssid = result.BSSID;
|
|
security = getSecurity(result);
|
|
wpsAvailable = security != SECURITY_EAP && result.capabilities.contains("WPS");
|
|
if (security == SECURITY_PSK)
|
|
pskType = getPskType(result);
|
|
networkId = -1;
|
|
mRssi = result.level;
|
|
mScanResult = result;
|
|
}
|
|
|
|
@Override
|
|
protected void onBindView(View view) {
|
|
super.onBindView(view);
|
|
ImageView signal = (ImageView) view.findViewById(R.id.signal);
|
|
if (mRssi == Integer.MAX_VALUE) {
|
|
signal.setImageDrawable(null);
|
|
} else {
|
|
signal.setImageLevel(getLevel());
|
|
signal.setImageResource(R.drawable.wifi_signal);
|
|
signal.setImageState((security != SECURITY_NONE) ?
|
|
STATE_SECURED : STATE_NONE, true);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public int compareTo(Preference preference) {
|
|
if (!(preference instanceof AccessPoint)) {
|
|
return 1;
|
|
}
|
|
AccessPoint other = (AccessPoint) preference;
|
|
// Active one goes first.
|
|
if (mInfo != null && other.mInfo == null) return -1;
|
|
if (mInfo == null && other.mInfo != null) return 1;
|
|
|
|
// Reachable one goes before unreachable one.
|
|
if (mRssi != Integer.MAX_VALUE && other.mRssi == Integer.MAX_VALUE) return -1;
|
|
if (mRssi == Integer.MAX_VALUE && other.mRssi != Integer.MAX_VALUE) return 1;
|
|
|
|
// Configured one goes before unconfigured one.
|
|
if (networkId != WifiConfiguration.INVALID_NETWORK_ID
|
|
&& other.networkId == WifiConfiguration.INVALID_NETWORK_ID) return -1;
|
|
if (networkId == WifiConfiguration.INVALID_NETWORK_ID
|
|
&& other.networkId != WifiConfiguration.INVALID_NETWORK_ID) return 1;
|
|
|
|
// Sort by signal strength.
|
|
int difference = WifiManager.compareSignalLevel(other.mRssi, mRssi);
|
|
if (difference != 0) {
|
|
return difference;
|
|
}
|
|
// Sort by ssid.
|
|
return ssid.compareToIgnoreCase(other.ssid);
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(Object other) {
|
|
if (!(other instanceof AccessPoint)) return false;
|
|
return (this.compareTo((AccessPoint) other) == 0);
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
int result = 0;
|
|
if (mInfo != null) result += 13 * mInfo.hashCode();
|
|
result += 19 * mRssi;
|
|
result += 23 * networkId;
|
|
result += 29 * ssid.hashCode();
|
|
return result;
|
|
}
|
|
|
|
boolean update(ScanResult result) {
|
|
if (ssid.equals(result.SSID) && security == getSecurity(result)) {
|
|
if (WifiManager.compareSignalLevel(result.level, mRssi) > 0) {
|
|
int oldLevel = getLevel();
|
|
mRssi = result.level;
|
|
if (getLevel() != oldLevel) {
|
|
notifyChanged();
|
|
}
|
|
}
|
|
// This flag only comes from scans, is not easily saved in config
|
|
if (security == SECURITY_PSK) {
|
|
pskType = getPskType(result);
|
|
}
|
|
refresh();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void update(WifiInfo info, DetailedState state) {
|
|
boolean reorder = false;
|
|
if (info != null && networkId != WifiConfiguration.INVALID_NETWORK_ID
|
|
&& networkId == info.getNetworkId()) {
|
|
reorder = (mInfo == null);
|
|
mRssi = info.getRssi();
|
|
mInfo = info;
|
|
mState = state;
|
|
refresh();
|
|
} else if (mInfo != null) {
|
|
reorder = true;
|
|
mInfo = null;
|
|
mState = null;
|
|
refresh();
|
|
}
|
|
if (reorder) {
|
|
notifyHierarchyChanged();
|
|
}
|
|
}
|
|
|
|
int getLevel() {
|
|
if (mRssi == Integer.MAX_VALUE) {
|
|
return -1;
|
|
}
|
|
return WifiManager.calculateSignalLevel(mRssi, 4);
|
|
}
|
|
|
|
WifiConfiguration getConfig() {
|
|
return mConfig;
|
|
}
|
|
|
|
WifiInfo getInfo() {
|
|
return mInfo;
|
|
}
|
|
|
|
DetailedState getState() {
|
|
return mState;
|
|
}
|
|
|
|
static String removeDoubleQuotes(String string) {
|
|
int length = string.length();
|
|
if ((length > 1) && (string.charAt(0) == '"')
|
|
&& (string.charAt(length - 1) == '"')) {
|
|
return string.substring(1, length - 1);
|
|
}
|
|
return string;
|
|
}
|
|
|
|
static String convertToQuotedString(String string) {
|
|
return "\"" + string + "\"";
|
|
}
|
|
|
|
/** Updates the title and summary; may indirectly call notifyChanged() */
|
|
private void refresh() {
|
|
setTitle(ssid);
|
|
|
|
Context context = getContext();
|
|
if (mState != null) { // This is the active connection
|
|
setSummary(Summary.get(context, mState));
|
|
} else if (mRssi == Integer.MAX_VALUE) { // Wifi out of range
|
|
setSummary(context.getString(R.string.wifi_not_in_range));
|
|
} else if (mConfig != null && mConfig.status == WifiConfiguration.Status.DISABLED) {
|
|
switch (mConfig.disableReason) {
|
|
case WifiConfiguration.DISABLED_AUTH_FAILURE:
|
|
setSummary(context.getString(R.string.wifi_disabled_password_failure));
|
|
break;
|
|
case WifiConfiguration.DISABLED_DHCP_FAILURE:
|
|
case WifiConfiguration.DISABLED_DNS_FAILURE:
|
|
setSummary(context.getString(R.string.wifi_disabled_network_failure));
|
|
break;
|
|
case WifiConfiguration.DISABLED_UNKNOWN_REASON:
|
|
setSummary(context.getString(R.string.wifi_disabled_generic));
|
|
}
|
|
} else { // In range, not disabled.
|
|
StringBuilder summary = new StringBuilder();
|
|
if (mConfig != null) { // Is saved network
|
|
summary.append(context.getString(R.string.wifi_remembered));
|
|
}
|
|
|
|
if (security != SECURITY_NONE) {
|
|
String securityStrFormat;
|
|
if (summary.length() == 0) {
|
|
securityStrFormat = context.getString(R.string.wifi_secured_first_item);
|
|
} else {
|
|
securityStrFormat = context.getString(R.string.wifi_secured_second_item);
|
|
}
|
|
summary.append(String.format(securityStrFormat, getSecurityString(true)));
|
|
}
|
|
|
|
if (mConfig == null && wpsAvailable) { // Only list WPS available for unsaved networks
|
|
if (summary.length() == 0) {
|
|
summary.append(context.getString(R.string.wifi_wps_available_first_item));
|
|
} else {
|
|
summary.append(context.getString(R.string.wifi_wps_available_second_item));
|
|
}
|
|
}
|
|
setSummary(summary.toString());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Generate and save a default wifiConfiguration with common values.
|
|
* Can only be called for unsecured networks.
|
|
* @hide
|
|
*/
|
|
protected void generateOpenNetworkConfig() {
|
|
if (security != SECURITY_NONE)
|
|
throw new IllegalStateException();
|
|
if (mConfig != null)
|
|
return;
|
|
mConfig = new WifiConfiguration();
|
|
mConfig.SSID = AccessPoint.convertToQuotedString(ssid);
|
|
mConfig.allowedKeyManagement.set(KeyMgmt.NONE);
|
|
}
|
|
}
|