android 实现指定wifi切换

女爷i 2022-08-24 11:51 457阅读 0赞

android 实现指定wifi切换 ,网上找了很多代码都有问题，借鉴其他人的整理了一份。

操作过程中发现始终切换失败，最终发现是密码问题。所连接设备虽然不需要密码，但这里连接时需要指定一个空密码

使用办法：

wifiUtils = new WifiUtils(CurrentStatusActivity.this);
    		boolean isEnable = wifiUtils.isEnable();
    		if (isEnable) {
    			// wifi已经打开
    			if (dialog != null) {

//关闭加载窗口
    				dialog.dismiss();
    			}
    			// 是否已经连接上了 指定前缀的wifi
    			if (wifiUtils.getSSID().contains(WifiUtils.wifi_ssid_suffix)) {
    //进行操作

} else {
    				// 1: 判断当前网络中有几个指定前缀的ssid
    				List<String> exsits = wifiUtils.getExistZXwifi();
    				if (exsits.size() == 0) {
    					//当前网络中没有指定wifi
    				} else if (exsits.size() == 1) {

//正确逻辑，写自己的的逻辑代码
    				} else {

//当前网络中有多个指定前缀ssid的 wifi ，提示框 提示用户选择。

wifi_dialog = new WifiSwitchDialog(this, exsits);
    					wifi_dialog.show();
    				}
    			}
    		} else {
    			// wifi 未打开
    			// 网络不可用,打开网络设置页面
    			dialog = new NetSetingDialog(this);
    			dialog.show();
    		}

import java.util.ArrayList;
    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.net.wifi.WifiManager.WifiLock;
    
    /**
     * wifi 操作
     * 
     * @author java_developer
     * 
     */
    public class WifiUtils {
    
    	public static String wifi_ssid_suffix = "Tp-link";
    
    	// 定义WifiManager对象
    	private WifiManager mWifiManager;
    	// 定义WifiInfo对象
    	private WifiInfo mWifiInfo;
    	// 扫描出的网络连接列表
    	private List<ScanResult> mWifiList;
    
    	// 定义一个WifiLock
    	WifiLock mWifiLock;
    
    	// 构造器
    	public WifiUtils(Context context) {
    		// 取得WifiManager对象
    		mWifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
    		// 取得WifiInfo对象
    		mWifiInfo = mWifiManager.getConnectionInfo();
    	}
    
    	// 打开WIFI
    	public boolean openWifi() {
    		if (!mWifiManager.isWifiEnabled()) {
    			return mWifiManager.setWifiEnabled(true);
    		} else {
    			return true;
    		}
    	}
    
    	// 关闭WIFI
    	public void closeWifi() {
    		if (mWifiManager.isWifiEnabled()) {
    			mWifiManager.setWifiEnabled(false);
    		}
    	}
    
    	public boolean isEnable() {
    		return mWifiManager.isWifiEnabled();
    	}
    
    	// 检查当前WIFI状态
    	public int checkState() {
    		return mWifiManager.getWifiState();
    	}
    
    	// 锁定WifiLock
    	public void acquireWifiLock() {
    		mWifiLock.acquire();
    	}
    
    	// 解锁WifiLock
    	public void releaseWifiLock() {
    		// 判断时候锁定
    		if (mWifiLock.isHeld()) {
    			mWifiLock.acquire();
    		}
    	}
    
    	// 创建一个WifiLock
    	public void creatWifiLock() {
    		mWifiLock = mWifiManager.createWifiLock("Test");
    	}
    
    	// 得到配置好的网络
    	public List<WifiConfiguration> getConfiguration() {
    		return mWifiConfiguration;
    	}
    
    	// 指定配置好的网络进行连接
    	public void connectConfiguration(int index) {
    		// 索引大于配置好的网络索引返回
    		if (index > mWifiConfiguration.size()) {
    			return;
    		}
    		// 连接配置好的指定ID的网络
    		mWifiManager.enableNetwork(mWifiConfiguration.get(index).networkId, true);
    	}
    
    	// 得到网络列表
    	public List<ScanResult> getWifiList() {
    		return mWifiList;
    	}
    
    	// 查看扫描结果
    	public StringBuilder lookUpScan() {
    		StringBuilder stringBuilder = new StringBuilder();
    		for (int i = 0; i < mWifiList.size(); i++) {
    			stringBuilder.append("Index_" + new Integer(i + 1).toString() + ":");
    			// 将ScanResult信息转换成一个字符串包
    			// 其中把包括：BSSID、SSID、capabilities、frequency、level
    			stringBuilder.append((mWifiList.get(i)).toString());
    			stringBuilder.append("/n");
    		}
    		return stringBuilder;
    	}
    
    	// 得到MAC地址
    	public String getMacAddress() {
    		return (mWifiInfo == null) ? "NULL" : mWifiInfo.getMacAddress();
    	}
    
    	// 得到接入点的BSSID
    	public String getBSSID() {
    		return (mWifiInfo == null) ? "NULL" : mWifiInfo.getBSSID();
    	}
    
    	public String getSSID() {
    		return (mWifiInfo == null) ? "NULL" : mWifiInfo.getSSID();
    	}
    
    	// 得到IP地址
    	public int getIPAddress() {
    		return (mWifiInfo == null) ? 0 : mWifiInfo.getIpAddress();
    	}
    
    	// 得到连接的ID
    	public int getNetworkId() {
    		return (mWifiInfo == null) ? 0 : mWifiInfo.getNetworkId();
    	}
    
    	// 得到WifiInfo的所有信息包
    	public String getWifiInfo() {
    		return (mWifiInfo == null) ? "NULL" : mWifiInfo.toString();
    	}
    
    	/**
    	 * 简介：wifi结合
    	 * 
    	 */
    	public int switchWifi(String wifi_ssid) {
    		String ssid = this.getSSID();
    		ssid = ssid.replace("\"", "");
    		if (ssid.contains(wifi_ssid)) {
    			// wifi已经加入相应wifi无需进行切换
    			// ping 是否通
    			boolean ping = new Tools().ping("2");
    			if (ping) {
    				return 0;
    			} else {
    				// 虽然加入了网络，但是网络不通
    				return 4;
    			}
    		} else {
    			// 首先判断当前wifi列表中是否有zx_wifr
    			WifiConfiguration tempConfig = this.IsExsits(wifi_ssid);
    			if (tempConfig != null) {
    				mWifiManager.removeNetwork(tempConfig.networkId);
    			}
    			// 进行切换
    			WifiConfiguration wcg = this.createWifiInfo(wifi_ssid,"", 1);
    			boolean success = this.addNetwork(wcg);
    			if (success) {
    				return 1;
    			} else {
    				return 2;
    			}
    		}
    	}
    
    	// 添加一个网络并连接
    	public boolean addNetwork(WifiConfiguration wcg) {
    		int wcgID = mWifiManager.addNetwork(wcg);
    		// 执行命令去连接
    		boolean b = mWifiManager.enableNetwork(wcgID, true);
    		mWifiManager.saveConfiguration();
    		return b;
    	}
    
    	// 断开指定ID的网络
    	public void disconnectWifi(int netId) {
    		mWifiManager.disableNetwork(netId);
    		mWifiManager.disconnect();
    	}
    
    	// 然后是一个实际应用方法，只验证过没有密码的情况：
    	/**
    	 * 第一参数是SSID的名称；第二个参数是指定SSID网络的密码，当不需要密码是置空（”“）；第三个参数是热点类型：1-无密码 /
    	 * 2-WEP密码验证（未测试）/ 3-WAP或WAP2 PSK密码验证。
    	 * 
    	 * @param SSID
    	 * @param Password
    	 * @param Type
    	 * @return
    	 */
    	public WifiConfiguration createWifiInfo(String wifi_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 = "\"" + wifi_ssid + "\"";
    
    		if (Type == 1) {
    			// WIFICIPHER_NOPASS
    			config.wepKeys[0] = "\"" + Password + "\"";
    			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;
    	}
    
    	// 网络连接列表
    	private List<WifiConfiguration> mWifiConfiguration;
    
    	public void startScan() {
    		mWifiManager.startScan();
    		// 得到扫描结果
    		mWifiList = mWifiManager.getScanResults();
    		// 得到配置好的网络连接
    		mWifiConfiguration = mWifiManager.getConfiguredNetworks();
    	}
    
    	public List<String> getExistZXwifi() {
    		List<String> wifis = new ArrayList<String>();
    		List<ScanResult> mWifiList = mWifiManager.getScanResults();
    		for (int i = 0; i < mWifiList.size(); i++) {
    			ScanResult sr = mWifiList.get(i);
    			String s_ssid = sr.SSID;
    			if (s_ssid.contains(wifi_ssid_suffix)) {
    				wifis.add(s_ssid);
    			}
    		}
    		return wifis;
    	}
    
    	private WifiConfiguration IsExsits(String SSID) {
    		if (mWifiManager == null) {
    			return null;
    		} else {
    			List<WifiConfiguration> existingConfigs = mWifiManager.getConfiguredNetworks();
    			for (int i = 0; i < existingConfigs.size(); i++) {
    				WifiConfiguration existingConfig = existingConfigs.get(i);
    				String c_ssid = existingConfig.SSID;
    				if (c_ssid.contains(SSID)) {
    					return existingConfig;
    				}
    			}
    		}
    		return null;
    	}
    }