AndroidWIFI自动连接

关于wifi自动连接的处理，研究了下，大体功能可以实现，但是如果手机没开wifi ，app打开wifi后，自动连接就有点鸡肋了 ，具体代码如下，

链接代码：

//=========================wifi自动连==================================================

private ProgressDialog pd;
private String wifiname;
private void searchWifi() {
WifiSearcher wifiSearcher = new WifiSearcher(this, new WifiSearcher.SearchWifiListener() {
@Override
public void onSearchWifiFailed(WifiSearcher.ErrorType errorType) {
// wifiFlag = true;
pd.dismiss();
ToastUtils.showToast(MainActivity.this, "search failed，please check the network connection");
}

@Override
public void onSearchWifiSuccess(List<String> results) {
pd.dismiss();
//得到制定的ssid
for (int i = 0; i < results.size(); i++) {
String ssid = results.get(i);
Log.e(TAG, "ssid------>:" + ssid);
if (ssid.length() < 4)
continue;
String s = ssid.substring(0, 4);
Log.e(TAG, "s value:" + s);
if (s.equals("FPV_")) {
wifiname = ssid;

//此处应该是通知 去开始连接
// EventBus.getDefault().post(wifiname);
UI_Handler.sendEmptyMessage(SCAN_TRUE);
break;
}
}


}
});
wifiSearcher.search();
pd = ProgressDialog.show(MainActivity.this, "", "Searching wifi, please wait for a moment...");

}

接下来是封装的两个工具类

package com.logic.utils;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiManager;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class WifiSearcher {

private static final int WIFI_SEARCH_TIMEOUT = 20; //扫描WIFI的超时时间

private Context mContext;
private WifiManager mWifiManager;
private WiFiScanReceiver mWifiReceiver;
private Lock mLock;
private Condition mCondition;
private SearchWifiListener mSearchWifiListener;
private boolean mIsWifiScanCompleted = false;

public static enum ErrorType {
SEARCH_WIFI_TIMEOUT,
NO_WIFI_FOUND,
}

public interface SearchWifiListener {
public void onSearchWifiFailed(ErrorType errorType);
public void onSearchWifiSuccess(List<String> results);
}

public WifiSearcher( Context context, SearchWifiListener listener ) {

mContext = context;
mSearchWifiListener = listener;

mLock = new ReentrantLock();
mCondition = mLock.newCondition();

mWifiManager=(WifiManager)mContext.getSystemService(Context.WIFI_SERVICE);

mWifiReceiver = new WiFiScanReceiver();
}

public void search() {

new Thread(new Runnable() {

@Override
public void run() {

//如果WIFI没有打开，则打开WIFI
if( !mWifiManager.isWifiEnabled() ) {
boolean flag = mWifiManager.setWifiEnabled(true);

//只有当成功打开后 才会执行下面语句
while(true){
if(flag)
break;
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

//注册接收WIFI扫描结果的监听类对象
mContext.registerReceiver(mWifiReceiver, new IntentFilter(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION));

//开始扫描
mWifiManager.startScan();

mLock.lock();

//阻塞等待扫描结果
try {
mIsWifiScanCompleted = false;
mCondition.await(WIFI_SEARCH_TIMEOUT, TimeUnit.SECONDS);
if( !mIsWifiScanCompleted ) {
mSearchWifiListener.onSearchWifiFailed(ErrorType.SEARCH_WIFI_TIMEOUT);
}
}
catch (InterruptedException e) {
e.printStackTrace();
}

mLock.unlock();

//删除注册的监听类对象
mContext.unregisterReceiver(mWifiReceiver);
}
}).start();
}

protected class WiFiScanReceiver extends BroadcastReceiver {

public void onReceive(Context c, Intent intent) {

//提取扫描结果
List<String> ssidResults = new ArrayList<String>();
List<ScanResult> scanResults = mWifiManager.getScanResults();
for(ScanResult result : scanResults ) {
ssidResults.add(result.SSID);
}

//检测扫描结果
if( ssidResults.isEmpty() ) {
mSearchWifiListener.onSearchWifiFailed(ErrorType.NO_WIFI_FOUND);
}
else {
mSearchWifiListener.onSearchWifiSuccess(ssidResults);
}

mLock.lock();
mIsWifiScanCompleted = true;
mCondition.signalAll();
mLock.unlock();
}
}
}

//扫描类

package com.logic.utils;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.wifi.SupplicantState;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.Build;
import android.util.Log;

import com.tomdxs.symago.WifiStateReceiver;

import java.lang.reflect.Method;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

import static android.content.ContentValues.TAG;

public class WifiConnector {

private static final int WIFI_CONNECT_TIMEOUT = 20; //连接WIFI的超时时间

private Context mContext;
private WifiManager mWifiManager;
private WifiInfo meWifiInfo;
private Lock mLock;
private Condition mCondition;
private WiFiConncetReceiver mWifiConnectReceiver;
private WifiConnectListener mWifiConnectListener;
private boolean mIsConnnected = false;
private int mNetworkID = -1;

//网络加密模式
public enum SecurityMode {
OPEN, WEP, WPA, WPA2
}

//通知连接结果的监听接口
public interface WifiConnectListener {
public void OnWifiConnectCompleted(boolean isConnected);
}

public WifiConnector( Context context , WifiConnectListener listener ) {

mContext = context;

mLock = new ReentrantLock();
mCondition = mLock.newCondition();

mWifiManager=(WifiManager)mContext.getSystemService(Context.WIFI_SERVICE);

// 取得WifiInfo对象
meWifiInfo = mWifiManager.getConnectionInfo();

mWifiConnectReceiver = new WiFiConncetReceiver();

mWifiConnectListener = listener;
}

public void connect( final String ssid, final String password, final SecurityMode mode ) {

new Thread(new Runnable() {

@Override
public void run() {

//如果WIFI没有打开，则打开WIFI
if( !mWifiManager.isWifiEnabled() ) {
mWifiManager.setWifiEnabled(true);
}

//注册连接结果监听对象
mContext.registerReceiver(mWifiConnectReceiver, new IntentFilter(WifiManager.SUPPLICANT_STATE_CHANGED_ACTION));

//连接指定SSID
if( !onConnect(ssid,password,mode) ) {
mWifiConnectListener.OnWifiConnectCompleted(false);
}
else {
mWifiConnectListener.OnWifiConnectCompleted(true);
}

//删除注册的监听类对象
mContext.unregisterReceiver(mWifiConnectReceiver);
}
}).start();
}

protected boolean onConnect( String ssid, String password, SecurityMode mode ) {

/* //添加新的网络配置
WifiConfiguration cfg = new WifiConfiguration();
cfg.SSID = "\"" + ssid + "\"";
if( password !=null && !"".equals(password) ) {
//这里比较关键，如果是WEP加密方式的网络，密码需要放到cfg.wepKeys[0]里面
if( mode == SecurityMode.WEP ) {
cfg.wepKeys[0] = "\"" + password + "\"";
cfg.wepTxKeyIndex = 0;
}
else {
cfg.preSharedKey = "\"" + password + "\"";
}
}
cfg.status = WifiConfiguration.Status.ENABLED;*/


if(WifiStateReceiver.getWifiName(mContext)){
return true;
}else{//如果没有链接fpv 那么断开当前连接 再重新连接 即可解决优先级问题
disConnectionWifi(getNetWordId());
LogUtil.e(TAG,"------>断开当前链接",true);
}


//先判断此配置本地是否存在
WifiConfiguration cfg = IsExsits(ssid);
if(cfg == null){
cfg = CreateWifiInfo(ssid,password,1);
}

//添加网络配置
mNetworkID = mWifiManager.addNetwork(cfg);

mLock.lock();

mIsConnnected = false;


Method connectMethod = connectWifiByReflectMethod(mNetworkID);
if (connectMethod == null) {
Log.i(TAG,
"connect wifi by enableNetwork method, Add by jiangping.li");
// 通用API
mWifiManager.enableNetwork(mNetworkID, true);
// //连接该网络
// if( !mWifiManager.enableNetwork(mNetworkID, true) ) {
// mLock.unlock();
// return false;
// }
}


try {
//等待连接结果
mCondition.await(WIFI_CONNECT_TIMEOUT, TimeUnit.SECONDS);
}
catch (InterruptedException e) {
e.printStackTrace();
}

mLock.unlock();

return mIsConnnected;
}

//监听系统的WIFI连接消息
protected class WiFiConncetReceiver extends BroadcastReceiver {

@Override
public void onReceive(Context context, Intent intent) {

if (!WifiManager.SUPPLICANT_STATE_CHANGED_ACTION.equals(intent.getAction())) {
return;
}

mLock.lock();

WifiInfo info = mWifiManager.getConnectionInfo();
if ( info.getNetworkId()==mNetworkID && info.getSupplicantState() == SupplicantState.COMPLETED ) {
mIsConnnected = true;
mCondition.signalAll();
}

mLock.unlock();
}
}

//==================================================================================================

// 密码连接方式
public WifiConfiguration CreateWifiInfo(String SSID, String Password,
int Type) {
WifiConfiguration config = new WifiConfiguration();
config.allowedAuthAlgorithms.clear();
config.allowedGroupCiphers.clear();
config.allowedKeyManagement.clear();
config.allowedPairwiseCiphers.clear();
config.allowedProtocols.clear();
config.SSID = "\"" + SSID + "\"";

if (Type == 1) // WIFICIPHER_NOPASS
{
//config.wepKeys[0] = "";
config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
//config.wepTxKeyIndex = 0;
}
if (Type == 2) // WIFICIPHER_WEP
{
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;
}
if (Type == 3) // WIFICIPHER_WPA
{
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;
}

// 添加一个网络并连接
public boolean addNetWork(WifiConfiguration configuration) {
int wcgId = mWifiManager.addNetwork(configuration);
return mWifiManager.enableNetwork(wcgId, true);
}


//判断config是否本地存在
public WifiConfiguration IsExsits(String SSID) {
List<WifiConfiguration> existingConfigs = mWifiManager
.getConfiguredNetworks();
for (WifiConfiguration existingConfig : existingConfigs) {
if (existingConfig.SSID.equals("\"" + SSID + "\"")) {
return existingConfig;
}
}
return null;
}

// 断开指定ID的网络
public void disConnectionWifi(int netId) {
mWifiManager.disableNetwork(netId);
mWifiManager.disconnect();
}

// 得到连接的ID
public int getNetWordId() {

return (meWifiInfo == null) ? 0 : meWifiInfo.getNetworkId();
}


/**
* 通过反射出不同版本的connect方法来连接Wifi
*
* @author jiangping.li
* @param netId
* @return
* @since MT 1.0
*
*/
private Method connectWifiByReflectMethod(int netId) {
Method connectMethod = null;
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {//>17
Log.i(TAG, "connectWifiByReflectMethod road 1");
// 反射方法： connect(int, listener) , 4.2 <= phone's android version
for (Method methodSub : mWifiManager.getClass()
.getDeclaredMethods()) {
if ("connect".equalsIgnoreCase(methodSub.getName())) {
Class<?>[] types = methodSub.getParameterTypes();
if (types != null && types.length > 0) {
if ("int".equalsIgnoreCase(types[0].getName())) {
connectMethod = methodSub;
}
}
}
}
if (connectMethod != null) {
try {
connectMethod.invoke(mWifiManager, netId, null);
} catch (Exception e) {
e.printStackTrace();
Log.i(TAG, "connectWifiByReflectMethod Android "
+ Build.VERSION.SDK_INT + " error!");
return null;
}
}
} else if (Build.VERSION.SDK_INT == Build.VERSION_CODES.JELLY_BEAN) {
// 反射方法: connect(Channel c, int networkId, ActionListener listener)
// 暂时不处理4.1的情况 , 4.1 == phone's android version
Log.i(TAG, "connectWifiByReflectMethod road 2");
} else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH
&& Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN) {
Log.i(TAG, "connectWifiByReflectMethod road 3");
// 反射方法：connectNetwork(int networkId) ,
// 4.0 <= phone's android version < 4.1
for (Method methodSub : mWifiManager.getClass()
.getDeclaredMethods()) {
if ("connectNetwork".equalsIgnoreCase(methodSub.getName())) {
Class<?>[] types = methodSub.getParameterTypes();
if (types != null && types.length > 0) {
if ("int".equalsIgnoreCase(types[0].getName())) {
connectMethod = methodSub;
}
}
}
}
if (connectMethod != null) {
try {
connectMethod.invoke(mWifiManager, netId);
} catch (Exception e) {
e.printStackTrace();
Log.i(TAG, "connectWifiByReflectMethod Android "
+ Build.VERSION.SDK_INT + " error!");
return null;
}
}
} else {
// < android 4.0
return null;
}
return connectMethod;
}




}