android连接wifi代码

package com.pingyijinren.common.util.network;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Queue;

import com.pingyijinren.guider.Constants;
import com.pingyijinren.guider.GuideApplication;

import android.content.Context;
import android.net.wifi.ScanResult;
import android.net.wifi.SupplicantState;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.net.wifi.WifiManager.ActionListener;
import android.os.AsyncTask;
import android.text.TextUtils;
import android.util.ArrayMap;
import android.util.Log;

/**本地的wifi工具类<br>
* 调用步骤<br>
* 1 startScan()
* 2 getLocalScanResults()
* 3 connect()
*
* 如果连接失败
* 4 disconnect()
*
*
* @author WenYF
*
*/
public class WifiTool {

private static final String TAG = "WifiTool";

private WifiManager nWifiManager;
private List<ScanResult> nWifiScanList;

private ArrayList<LocalScanResult> nLocalScanResults;
private Collection<WifiListener> nWifiListeners;

public void addScanStateListener(WifiListener listener) {
nWifiListeners.add(listener);
}

public void removeScanStateListener(WifiListener listener) {
nWifiListeners.remove(listener);
}

private AsyncTask<String, Integer, String> nScanTask;
private boolean nIsDestory;
private boolean nIsStopScan;
private boolean nIsStopConnect;

public WifiTool(Context context) {
nIsStopConnect = true;
nIsDestory = false;
nIsStopScan = true;
nWifiListeners = new ArrayList<WifiTool.WifiListener>();
nLocalScanResults = new ArrayList<LocalScanResult>();

nWifiManager = (WifiManager) context
.getSystemService(Context.WIFI_SERVICE);

nWifiScanList = null;
}

/**
* 注销工具
*/
public void destory() {
stopScan();

nIsDestory = true;
nLocalScanResults.clear();
nWifiListeners.clear();

}

/**
* 关闭WIFI
*/
public void closeWifi() {
if (nWifiManager.isWifiEnabled()) {
nWifiManager.setWifiEnabled(false);
}
}

/**
* 开始wifi扫描
*/
public void startScan() {
nScanTask = new AsyncTask<String, Integer, String>() {
@Override
protected String doInBackground(String... params) {
int sleepTime = 2000;

while (!nIsDestory && !nIsStopScan) {
if (!isEnable()) {
enableWifi(true);
}

publishProgress(0);
// 检索
scanWifi();
nLocalScanResults.clear();

// 得到本地的results
ArrayMap<String, LocalScanResult> nTmpLocalScanResults =
new ArrayMap<String, LocalScanResult>();
if (nWifiScanList != null && nWifiScanList.size() > 0) {
for (ScanResult result : nWifiScanList) {
LocalScanResult lsr = new LocalScanResult(result);
nTmpLocalScanResults.put(result.SSID , lsr);
}
sleepTime = Constants.WIFI_SCAN_EXPIRE;
}

// 得到正在连接的wifi信息
WifiInfo wifiInfo = nWifiManager.getConnectionInfo();

if (wifiInfo != null) {
Log.w(TAG, "wifi info = " + wifiInfo.toString());
String ssid = wifiInfo.getSSID().replaceAll("\"", "");

if (!TextUtils.isEmpty(ssid) && wifiInfo.getSupplicantState() == SupplicantState.COMPLETED) {
LocalScanResult lsr = nTmpLocalScanResults.get(ssid);
Log.w(TAG, "lsr = " + lsr);
if (lsr != null) {
lsr.setConnect(true);
// 这里把连接上的放第一个
nLocalScanResults.add(lsr);
nTmpLocalScanResults.remove(ssid);
}
}
}

// 这里对nTmpLocalScanResults进行信号排序
for (LocalScanResult result : sortResults(nTmpLocalScanResults)) {
nLocalScanResults.add(result);
}

// 打印结果
for (LocalScanResult result : nLocalScanResults) {
Log.d(TAG, result.toString());
}

// 通知完成了一次检索
publishProgress(1);

if (sleepTime > Constants.WIFI_SCAN_EXPIRE) {
sleepTime = Constants.WIFI_SCAN_EXPIRE;
}

try {
Thread.sleep(sleepTime);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
return null;
}

@Override
protected void onProgressUpdate(Integer... values) {
super.onProgressUpdate(values);

if (nWifiListeners == null) {
return;
}

if (values[0] == 0) {
for (WifiListener listenr : nWifiListeners) {
listenr.onScanStart();
}
} else {
for (WifiListener listenr : nWifiListeners) {
listenr.onScanFinish();
}
}
}
};
nIsStopScan = false;
nScanTask.execute();
}

/**
* 关闭扫描wifi
*/
public void stopScan() {
nIsStopScan = true;

if (nScanTask != null) {
nScanTask.cancel(true);
}
}

private void scanWifi() {
boolean scan = nWifiManager.startScan();
Log.i(TAG, "startScan result:" + scan);
nWifiScanList = nWifiManager.getScanResults();

if (nWifiScanList != null) {
Log.i(TAG, "startScan result:" + nWifiScanList.size());
for (int i = 0; i < nWifiScanList.size(); i++) {
ScanResult result = nWifiScanList.get(i);
Log.i(TAG, "startScan result[" + i + "]" + result.SSID + ","
+ result.BSSID);
}
Log.i(TAG, "startScan result end.");
} else {
Log.i(TAG, "startScan result is null.");
}
}

/**连接一个扫描到的wifi，结果通过通知回调
* @param result result
* @param password 连接密码，如果wifi不需要密码，这个参数会被忽略掉
* @param timeout 超时
*/
public void connect(LocalScanResult result, String password, int timeout) {
// 如果result不全，那么通知连接失败
if (result == null || result.getResult() == null) {
for (WifiListener listener : nWifiListeners) {
listener.onConnectFinish(result, true);
}
}

// 创建wifi的连接配置
WifiConfiguration config = createWifiConfiguration(result.getResult().SSID
, password
, result.getPasswordType());

// 开始连接
connect(result, config, timeout);
}

/**
* @param result result
* @param config 连接配置
* @param timeout 超时
*/
private void connect(LocalScanResult result, final WifiConfiguration config, int timeout) {
int networkId = nWifiManager.addNetwork(config);
Log.w(TAG, "networkID = " + networkId);
if (networkId < 0) {
for (WifiListener listener : nWifiListeners) {
listener.onConnectFinish(result, false);
}
} else {
connect(result, networkId, config, timeout, true);
}
}

/**
* @param result result
* @param networkId 一个由wifiservice生成的连接id
* @param config 配置
* @param timeout 超时
* @param otherStop 关闭其他的wifi
*/
private void connect(final LocalScanResult result, final int networkId
, final WifiConfiguration config, final int timeout
, final boolean otherStop) {

nIsStopConnect = false;

// 主线程通知开始连接wifi
GuideApplication.getHandler().post(new Runnable() {
@Override
public void run() {
for (WifiListener listener : nWifiListeners) {
listener.onConnectStart(result);
}
}
});

// 通过调用隐藏代码来连接wifi设备
nWifiManager.connect(networkId, new ActionListener() {
@Override
public void onSuccess() {
// 没有接口去监听连接的状态
// 循环去获取wifi的连接状态
int timeCount = 0;

boolean isConnect = isConnect(result.getResult().SSID);
// 如果连接的SSID相同，并且已经连上了
while (!isConnect && timeCount < timeout && !nIsStopConnect) {
isConnect = isConnect(result.getResult().SSID);

try {
Thread.sleep(1000);
timeCount += 1000;
} catch (InterruptedException e) {
e.printStackTrace();
}
}

if (nIsStopConnect) {
return;
}

if (!isConnect) {
GuideApplication.getHandler().post(new Runnable() {
@Override
public void run() {
for (WifiListener listener : nWifiListeners) {
listener.onConnectFinish(result, false);
}
}
});
} else {
//Log.w(TAG, "enable ret = " + nWifiManager.enableNetwork(networkId, true));
GuideApplication.getHandler().post(new Runnable() {
@Override
public void run() {
for (WifiListener listener : nWifiListeners) {
listener.onConnectFinish(result, true);
}
}
});
}
}

@Override
public void onFailure(int arg0) {
Log.w(TAG, "onFailure code = " + arg0);
GuideApplication.getHandler().post(new Runnable() {
@Override
public void run() {
for (WifiListener listener : nWifiListeners) {
listener.onConnectFinish(result, false);
}
}
});
}
});
}

/**
* 断开正在进行的连接
*/
public void stopConnect() {
nIsStopConnect = true;
WifiInfo info = nWifiManager.getConnectionInfo();
if (info != null && info.getSSID() != null) {
if (info.getNetworkId() >= 0) {
nWifiManager.disableNetwork(info.getNetworkId());
}
nWifiManager.disconnect();
}
}

/**创建一个wifi连接配置
* @param SSID ssid 没有引号
* @param password 密码
* @param type 类型 1 不要密码， 2 要密码， 3要密码 {@link LocalScanResult#getPasswordType()}
* @return
*/
private WifiConfiguration createWifiConfiguration(String SSID
, String password, int type) {
Log.i(TAG, "SSID:" + SSID + ",password:" + password);
WifiConfiguration config = new WifiConfiguration();
config.allowedAuthAlgorithms.clear();
config.allowedGroupCiphers.clear();
config.allowedKeyManagement.clear();
config.allowedPairwiseCiphers.clear();
config.allowedProtocols.clear();
config.SSID = "\"" + SSID + "\"";

WifiConfiguration tempConfig = this.getExistWifiConfiguration(SSID);

if (tempConfig != null) {
nWifiManager.removeNetwork(tempConfig.networkId);
} else {
Log.i(TAG, "IsExsits is null.");
}

// WIFICIPHER_NOPASS
if (type == 1)
{
Log.i(TAG, "Type =1.");
// 不把这个注释掉，不要密码的wifi返回-1id
//config.wepKeys[0] = "";
config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
config.wepTxKeyIndex = 0;
}

// WIFICIPHER_WEP
if (type == 2)
{
Log.i(TAG, "Type =2.");
config.hiddenSSID = true;
config.wepKeys[0] = "\"" + password + "\"";
config.allowedAuthAlgorithms
.set(WifiConfiguration.AuthAlgorithm.SHARED);
config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);
config.allowedGroupCiphers
.set(WifiConfiguration.GroupCipher.WEP104);
config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
config.wepTxKeyIndex = 0;
}

// WIFICIPHER_WPA
if (type == 3)
{

Log.i(TAG, "Type =3.");
config.preSharedKey = "\"" + password + "\"";

config.hiddenSSID = true;
config.allowedAuthAlgorithms
.set(WifiConfiguration.AuthAlgorithm.OPEN);
config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
config.allowedPairwiseCiphers
.set(WifiConfiguration.PairwiseCipher.TKIP);
config.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
config.allowedPairwiseCiphers
.set(WifiConfiguration.PairwiseCipher.CCMP);
config.status = WifiConfiguration.Status.ENABLED;
}
return config;
}

/** 得到wifi名为ssid的配置
* @param SSID
* @return
*/
private WifiConfiguration getExistWifiConfiguration(String SSID) {
List<WifiConfiguration> existingConfigs = nWifiManager
.getConfiguredNetworks();
for (WifiConfiguration existingConfig : existingConfigs) {
if (existingConfig.SSID.equals("\"" + SSID + "\"")) {
return existingConfig;
}
}
return null;
}

/**
* @return wifi是否打开
*/
public boolean isEnable() {
return nWifiManager.isWifiEnabled();
}

/**wifi开关
* @param enable 是否打开
* @return 操作成功返回true
*/
public boolean enableWifi(boolean enable) {
return nWifiManager.setWifiEnabled(enable);
}

/**这个ssid的wifi是否已经连上
* @param ssid  不用加引号
* @return
*/
public boolean isConnect(String ssid) {
WifiInfo info = nWifiManager.getConnectionInfo();
Log.w(TAG, "wifi info = " + info);
if (info != null && info.getSSID().equals("\"" + ssid + "\"")
&& info.getSupplicantState() == SupplicantState.COMPLETED) {
return true;
} else {
return false;
}
}

/**得到本地封装的wifi list
* @return
*/
public ArrayList<LocalScanResult> getLocalScanResults() {
return new ArrayList<LocalScanResult>(nLocalScanResults);
}

/**对arrayMaps进行排序
* @param arrayMaps
* @return
*/
private ArrayList<LocalScanResult> sortResults(ArrayMap<String, LocalScanResult> arrayMaps) {
ArrayList<LocalScanResult> list = new ArrayList<LocalScanResult>();
for (int i = 0; i < arrayMaps.size() - 1; i++) {
for(int j = i + 1; j < arrayMaps.size(); j++) {
LocalScanResult iValue = arrayMaps.valueAt(i);
LocalScanResult jValue = arrayMaps.valueAt(j);
if (jValue.getSingnal() > iValue.getSingnal()) {
arrayMaps.setValueAt(i, jValue);
arrayMaps.setValueAt(j, iValue);
}
}

list.add(arrayMaps.valueAt(i));
}

return list;
}

/**动作监听<br>
* TODO 如果有必要得到正在连接的状态（如握手，验证，授权等）。
* {@link WifiTool#connect(LocalScanResult, int, WifiConfiguration, int, boolean)}
* 可以来完成这样的监听
* @author WenYF
*
*/
public interface WifiListener {
public void onScanStart();
public void onScanFinish();
public void onConnectStart(LocalScanResult conf);
public void onConnectFinish(LocalScanResult conf, boolean isSuccess);
}

public class LocalScanResult {

private boolean isConnect;

private ScanResult result;

public LocalScanResult(ScanResult result) {
isConnect = false;
this.result = result;
}

public void setConnect(boolean isConnect) {
this.isConnect = isConnect;
}

public boolean isConnect() {
return isConnect;
}

public ScanResult getResult() {
return result;
}

public int getPasswordType() {
if (result == null) {
Log.i("LocalScanResult", "result == null");
return 1;
}

if (result.capabilities.contains("WEP")) {
return 2;
} else if (result.capabilities.contains("WPA")) {
return 3;
} else {
return 1;
}
}

public int getSingnal() {
int signal = WifiManager.calculateSignalLevel(result.level, 4);
return  signal;
}

@Override
public String toString() {
return "LocalScanResult [isConnect=" + isConnect + ", result=" + result
+ ", signal=" + getSingnal() + "]";
}

}
}