Android Wifi --自动连接指定SSID（各种加密方式均可）

Android Wifi API参考网站这里写链接内容

1.开始先加入wifi权限

<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" >
</uses-permission>
<uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" >
</uses-permission>
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" >
</uses-permission>
<uses-permission android:name="android.permission.CHANGE_WIFI_STATE" >
</uses-permission>

2.自动连接指定SSID实现代码

wificonnect.java

import java.util.List;
import android.content.Context;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.text.TextUtils;
import android.util.Log;

public class WifiConnect {
private static final String TAG = "WifiConnect";
//定义WifiManager对象
private  WifiManager mWifiManager;
// 定义WifiInfo对象
private WifiInfo mWifiInfo;
private AccessPoint mAccessPoint;
private ScanResult mresult;
private Context mcontext;

//构造函数
public WifiConnect(Context context){
mcontext = context;
// 取得WifiManager对象
mWifiManager = (WifiManager)context.getSystemService(Context.WIFI_SERVICE);
// 取得WifiInfo对象
mWifiInfo = mWifiManager.getConnectionInfo();
}

//打开wifi功能
private boolean OpenWifi(){
boolean bRet = true;
if (!mWifiManager.isWifiEnabled()){
bRet = mWifiManager.setWifiEnabled(true);
}
return bRet;
}

//从扫描结果中提取需要的wifi
private boolean getScanResultsBySSID(String ssid){
List<ScanResult> list = mWifiManager.getScanResults();
for (ScanResult result : list){
if (TextUtils.equals(result.SSID, ssid)){
mresult=result;
return true;
}
}
return false;
}

//查看以前是否也配置过这个网络
private WifiConfiguration IsExsits(String SSID){
List<WifiConfiguration> existingConfigs = mWifiManager.getConfiguredNetworks();
for (WifiConfiguration existingConfig : existingConfigs) {
if (existingConfig.SSID.equals("\""+SSID+"\"")){
return existingConfig;
}
}
return null;
}

//提供一个外部接口，传入要连接的无线网
public boolean Connect(String SSID, String Password)
{
if(!this.OpenWifi())
{
return false;
}
//开启wifi功能需要一段时间(我在手机上测试一般需要1-3秒左右)，所以要等到wifi
//状态变成WifiManager.WIFI_STATE_ENABLED的时候才能执行下面的语句
while( !(mWifiManager.getWifiState()==WifiManager.WIFI_STATE_ENABLED) )
{
try{
//为了避免程序一直while循环，让它睡个100毫秒在检测……
Thread.currentThread();
Thread.sleep(100);
}
catch(InterruptedException ie){
}
}
Log.i(TAG, "---BeginScan-SSID---");
//等待扫描完wifi
while( !getScanResultsBySSID(SSID) )
{
try{
//为了避免程序一直while循环，让它睡个100毫秒在检测……
Thread.currentThread();
Thread.sleep(100);
}
catch(InterruptedException ie){
}
}
Log.i(TAG, "---EndScan-SSID---");
WifiConfiguration config = new WifiConfiguration();
mAccessPoint = new AccessPoint(mcontext,mresult);
//判断以前是否保存过此WIFI环境
WifiConfiguration tempConfig = this.IsExsits(SSID);
if(tempConfig != null){
mWifiManager.removeNetwork(tempConfig.networkId);
}
config = mAccessPoint.getConfig(Password, null, null);
Log.i(TAG, "----wifi--config--"+config);
int netID = mWifiManager.addNetwork(config);
boolean bRet = mWifiManager.enableNetwork(netID,false);
if(bRet){
//保持WIFI配置文件
mWifiManager.saveConfiguration();
}
Log.i(TAG, "------WifiConnectState---"+bRet);
return bRet;
}

}

AccessPoint.java 此文件是从Android Setting 源码中提取出来的

package com.example.wifihotinterface;

import static android.net.wifi.WifiConfiguration.INVALID_NETWORK_ID;
import android.content.Context;
import android.net.LinkProperties;
import android.net.NetworkInfo.DetailedState;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiConfiguration.AuthAlgorithm;
import android.net.wifi.WifiConfiguration.IpAssignment;
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.security.Credentials;
import android.text.TextUtils;
import android.util.Log;
import com.example.wifihotinterface.R;

public 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 String KEYSTORE_SPACE = WifiConfiguration.KEYSTORE_URI;

/** 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 boolean isLock() {
return security != 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);
loadConfig(config);
}

AccessPoint(Context context, ScanResult result) {
super(context);
loadResult(result);
}

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
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) {
}
}
// This flag only comes from scans, is not easily saved in config
if (security == SECURITY_PSK) {
pskType = getPskType(result);
}
return true;
}
return false;
}
void update(WifiInfo info, DetailedState state) {
if (info != null && networkId != WifiConfiguration.INVALID_NETWORK_ID
&& networkId == info.getNetworkId()) {
mRssi = info.getRssi();
mInfo = info;
mState = state;
} else if (mInfo != null) {
mInfo = null;
mState = null;
}
}
int getLevel() {
if (mRssi == Integer.MAX_VALUE) {
return -1;
}
return WifiManager.calculateSignalLevel(mRssi, 5);
}
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 + "\"";
}
/**
* 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);
}
public static boolean requireKeyStore(WifiConfiguration config) {
if (config == null) {
return false;
}
if (!TextUtils.isEmpty(config.key_id.value())) {
return true;
}
String values[] = { config.ca_cert.value(), config.client_cert.value() };
for (String value : values) {
if (value != null && value.startsWith(KEYSTORE_SPACE)) {
return true;
}
}
return false;
}
public boolean isEqualAP(WifiInfo info) {
if (info == null) {
return false;
}
return ssid.equals(removeDoubleQuotes(info.getSSID()));
}
public boolean hasValidNetworkId() {
return networkId != INVALID_NETWORK_ID;
}
public WifiConfiguration getConfig(String password, IpAssignment ipAssignment, LinkProperties linkProperties) {
WifiConfiguration config = new WifiConfiguration();

if (networkId == INVALID_NETWORK_ID) {
config.SSID = AccessPoint.convertToQuotedString(ssid);
} else {
config.networkId = networkId;
}
switch (security) {
case AccessPoint.SECURITY_NONE:
config.allowedKeyManagement.set(KeyMgmt.NONE);
break;
case AccessPoint.SECURITY_WEP:
config.allowedKeyManagement.set(KeyMgmt.NONE);
config.allowedAuthAlgorithms.set(AuthAlgorithm.OPEN);
config.allowedAuthAlgorithms.set(AuthAlgorithm.SHARED);
if (password.length() != 0) {
int length = password.length();
// WEP-40, WEP-104, and 256-bit WEP (WEP-232?)
if ((length == 10 || length == 26 || length == 58)
&& password.matches("[0-9A-Fa-f]*")) {
config.wepKeys[0] = password;
} else {
config.wepKeys[0] = '"' + password + '"';
}
}
break;
case AccessPoint.SECURITY_PSK:
config.allowedKeyManagement.set(KeyMgmt.WPA_PSK);
if (password.length() != 0) {
if (password.matches("[0-9A-Fa-f]{64}")) {
config.preSharedKey = password;
} else {
config.preSharedKey = '"' + password + '"';
}
}
break;
case AccessPoint.SECURITY_EAP:
config.allowedKeyManagement.set(KeyMgmt.WPA_EAP);
config.allowedKeyManagement.set(KeyMgmt.IEEE8021X);
config.eap.setValue("");
config.phase2.setValue("");
config.ca_cert.setValue(Credentials.CA_CERTIFICATE);
config.client_cert.setValue(Credentials.USER_CERTIFICATE);
final boolean isEmptyKeyId = true;
config.key_id.setValue("");
config.engine
.setValue(isEmptyKeyId ? WifiConfiguration.ENGINE_DISABLE
: WifiConfiguration.ENGINE_ENABLE);
config.engine_id.setValue(isEmptyKeyId ? ""
: WifiConfiguration.KEYSTORE_ENGINE_ID);
config.identity.setValue("");
config.anonymous_identity.setValue("");
if (password.length() != 0) {
config.password.setValue(password);
}
break;
default:
return null;
}
if (ipAssignment != null) {
config.ipAssignment = ipAssignment;
}
if (linkProperties != null) {
config.linkProperties = new LinkProperties(linkProperties);
}
mConfig = config;
return config;
}
public void invalidNetworkId() {
networkId = INVALID_NETWORK_ID;
}
public String getStatus() {
String result = "";
Context context = getContext();
if (mState != null) { // This is the active connection
result = Summary.get(context, mState);
} else if (mRssi == Integer.MAX_VALUE) { // Wifi out of range
result = 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:
result = context.getString(R.string.wifi_disabled_password_failure);
break;
case WifiConfiguration.DISABLED_DHCP_FAILURE:
case WifiConfiguration.DISABLED_DNS_FAILURE:
result = context.getString(R.string.wifi_disabled_network_failure);
break;
case WifiConfiguration.DISABLED_UNKNOWN_REASON:
result = 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));
}
result = summary.toString();
}
return result;
}
}

Summary.java 此文件也是从Android Setting源码中提取

import com.example.wifihotinterface.R;
import android.content.Context;
import android.net.NetworkInfo.DetailedState;

public class Summary {
static String get(Context context, String ssid, DetailedState state) {
String[] formats = context.getResources().getStringArray((ssid == null)
? R.array.wifi_status : R.array.wifi_status_with_ssid);
int index = state.ordinal();

if (index >= formats.length || formats[index].length() == 0) {
return null;
}
return String.format(formats[index], ssid);
}

static String get(Context context, DetailedState state) {
if (state == DetailedState.VERIFYING_POOR_LINK)
state = DetailedState.CONNECTED;
return get(context, null, state);
}
}

有些标签需要自己添加。

此文自己学习总结，有错请指出。