Android开发——自动连接指定SSID的wifi热点（不加密/加密）

2021-11-03 23:51:55

最近在做一个项目，其中涉及到一块“自动连接已存在的wifi热点”的功能，在网上查阅了大量资料，五花八门，但其中一些说的很简单，即不能实现傻瓜式的拿来就用，有些说的很详细，但其中不乏些许错误造成功能无法实现，经过浣熊多方努力，终于成功将功能实现，遂将一点点小成就拿出来与大家分享。


首先需要感谢这篇文章的作者：http://blog.chinaunix.net/uid-22342564-id-3228565.html

在这篇文章中，作者定义了一个wifi工具类，其中存在着操作wifi的各种方法，其中有一些错误我以改正，正确的代码如下（创建一个名为WifiAdmin.java的文件，以下代码中没有包声明和import，请自行添加）：

[java] view plaincopy
  1. public class WifiAdmin {   
  2.     // 定义WifiManager对象    
  3.     private WifiManager mWifiManager;   
  4.     // 定义WifiInfo对象    
  5.     private WifiInfo mWifiInfo;   
  6.     // 扫描出的网络连接列表    
  7.     private List<ScanResult> mWifiList;   
  8.     // 网络连接列表    
  9.     private List<WifiConfiguration> mWifiConfiguration;   
  10.     // 定义一个WifiLock    
  11.     WifiLock mWifiLock;   
  12.   
  13.    
  14.     // 构造器    
  15.     public WifiAdmin(Context context) {   
  16.         // 取得WifiManager对象    
  17.         mWifiManager = (WifiManager) context   
  18.                 .getSystemService(Context.WIFI_SERVICE);   
  19.         // 取得WifiInfo对象    
  20.         mWifiInfo = mWifiManager.getConnectionInfo();   
  21.     }   
  22.    
  23.     // 打开WIFI    
  24.     public void openWifi() {   
  25.         if (!mWifiManager.isWifiEnabled()) {   
  26.             mWifiManager.setWifiEnabled(true);   
  27.         }   
  28.     }   
  29.    
  30.     // 关闭WIFI    
  31.     public void closeWifi() {   
  32.         if (mWifiManager.isWifiEnabled()) {   
  33.             mWifiManager.setWifiEnabled(false);   
  34.         }   
  35.     }   
  36.    
  37.     // 检查当前WIFI状态    
  38.     public int checkState() {   
  39.         return mWifiManager.getWifiState();   
  40.     }   
  41.    
  42.     // 锁定WifiLock    
  43.     public void acquireWifiLock() {   
  44.         mWifiLock.acquire();   
  45.     }   
  46.    
  47.     // 解锁WifiLock    
  48.     public void releaseWifiLock() {   
  49.         // 判断时候锁定    
  50.         if (mWifiLock.isHeld()) {   
  51.             mWifiLock.acquire();   
  52.         }   
  53.     }   
  54.    
  55.     // 创建一个WifiLock    
  56.     public void creatWifiLock() {   
  57.         mWifiLock = mWifiManager.createWifiLock("Test");   
  58.     }   
  59.    
  60.     // 得到配置好的网络    
  61.     public List<WifiConfiguration> getConfiguration() {   
  62.         return mWifiConfiguration;   
  63.     }   
  64.    
  65.     // 指定配置好的网络进行连接    
  66.     public void connectConfiguration(int index) {   
  67.         // 索引大于配置好的网络索引返回    
  68.         if (index > mWifiConfiguration.size()) {   
  69.             return;   
  70.         }   
  71.         // 连接配置好的指定ID的网络    
  72.         mWifiManager.enableNetwork(mWifiConfiguration.get(index).networkId,   
  73.                 true);   
  74.     }   
  75.    
  76.     public void startScan() {   
  77.         mWifiManager.startScan();   
  78.         // 得到扫描结果    
  79.         mWifiList = mWifiManager.getScanResults();   
  80.         // 得到配置好的网络连接    
  81.         mWifiConfiguration = mWifiManager.getConfiguredNetworks();   
  82.     }   
  83.    
  84.     // 得到网络列表    
  85.     public List<ScanResult> getWifiList() {   
  86.         return mWifiList;   
  87.     }   
  88.    
  89.     // 查看扫描结果    
  90.     public StringBuilder lookUpScan() {   
  91.         StringBuilder stringBuilder = new StringBuilder();   
  92.         for (int i = 0; i < mWifiList.size(); i++) {   
  93.             stringBuilder   
  94.                     .append("Index_" + new Integer(i + 1).toString() + ":");   
  95.             // 将ScanResult信息转换成一个字符串包    
  96.             // 其中把包括：BSSID、SSID、capabilities、frequency、level    
  97.             stringBuilder.append((mWifiList.get(i)).toString());   
  98.             stringBuilder.append("/n");   
  99.         }   
  100.         return stringBuilder;   
  101.     }  
  102.    
  103.     // 得到MAC地址    
  104.     public String getMacAddress() {   
  105.         return (mWifiInfo == null) ? "NULL" : mWifiInfo.getMacAddress();   
  106.     }   
  107.    
  108.     // 得到接入点的BSSID    
  109.     public String getBSSID() {   
  110.         return (mWifiInfo == null) ? "NULL" : mWifiInfo.getBSSID();   
  111.     }   
  112.    
  113.     // 得到IP地址    
  114.     public int getIPAddress() {   
  115.         return (mWifiInfo == null) ? 0 : mWifiInfo.getIpAddress();   
  116.     }   
  117.    
  118.     // 得到连接的ID    
  119.     public int getNetworkId() {   
  120.         return (mWifiInfo == null) ? 0 : mWifiInfo.getNetworkId();   
  121.     }   
  122.    
  123.     // 得到WifiInfo的所有信息包    
  124.     public String getWifiInfo() {   
  125.         return (mWifiInfo == null) ? "NULL" : mWifiInfo.toString();   
  126.     }   
  127.    
  128.     // 添加一个网络并连接    
  129.     public void addNetwork(WifiConfiguration wcg) {   
  130.      int wcgID = mWifiManager.addNetwork(wcg);   
  131.      boolean b =  mWifiManager.enableNetwork(wcgID, true);   
  132.      System.out.println("a--" + wcgID);  
  133.      System.out.println("b--" + b);  
  134.     }   
  135.    
  136.     // 断开指定ID的网络    
  137.     public void disconnectWifi(int netId) {   
  138.         mWifiManager.disableNetwork(netId);   
  139.         mWifiManager.disconnect();   
  140.     }   
  141.    
  142. //然后是一个实际应用方法，只验证过没有密码的情况：  
  143.    
  144.     public WifiConfiguration CreateWifiInfo(String SSID, String Password, int Type)   
  145.     {   
  146.           WifiConfiguration config = new WifiConfiguration();     
  147.            config.allowedAuthAlgorithms.clear();   
  148.            config.allowedGroupCiphers.clear();   
  149.            config.allowedKeyManagement.clear();   
  150.            config.allowedPairwiseCiphers.clear();   
  151.            config.allowedProtocols.clear();   
  152.           config.SSID = "\"" + SSID + "\"";     
  153.             
  154.           WifiConfiguration tempConfig = this.IsExsits(SSID);             
  155.           if(tempConfig != null) {    
  156.               mWifiManager.removeNetwork(tempConfig.networkId);    
  157.           }  
  158.             
  159.           if(Type == 1) //WIFICIPHER_NOPASS  
  160.           {   
  161.                config.wepKeys[0] = "";   
  162.                config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);   
  163.                config.wepTxKeyIndex = 0;   
  164.           }   
  165.           if(Type == 2) //WIFICIPHER_WEP  
  166.           {   
  167.               config.hiddenSSID = true;  
  168.               config.wepKeys[0]= "\""+Password+"\"";   
  169.               config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.SHARED);   
  170.               config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);   
  171.               config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);   
  172.               config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);   
  173.               config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP104);   
  174.               config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);   
  175.               config.wepTxKeyIndex = 0;   
  176.           }   
  177.           if(Type == 3) //WIFICIPHER_WPA  
  178.           {   
  179.           config.preSharedKey = "\""+Password+"\"";   
  180.           config.hiddenSSID = true;     
  181.           config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);     
  182.           config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);                           
  183.           config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);                           
  184.           config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);                      
  185.           //config.allowedProtocols.set(WifiConfiguration.Protocol.WPA);    
  186.           config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);  
  187.           config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);  
  188.           config.status = WifiConfiguration.Status.ENABLED;     
  189.           }  
  190.            return config;   
  191.     }   
  192.       
  193.     private WifiConfiguration IsExsits(String SSID)    
  194.     {    
  195.         List<WifiConfiguration> existingConfigs = mWifiManager.getConfiguredNetworks();    
  196.            for (WifiConfiguration existingConfig : existingConfigs)     
  197.            {    
  198.              if (existingConfig.SSID.equals("\""+SSID+"\""))    
  199.              {    
  200.                  return existingConfig;    
  201.              }    
  202.            }    
  203.         return null;     
  204.     }  
  205.     
  206. }  
  207. //分为三种情况：1没有密码2用wep加密3用wpa加密  

改动主要集中在CreateWifiInfo这个方法中，并且添加了一个私有方法：

（1）将与方法的第三个参数有关的变量都改成int型，或者使用原作者的枚举型（存在bug需要改正），但枚举会在后续的开发中遇到些困难；

（2）在if(type == 3)中注释掉“config.allowedProtocols.set(WifiConfiguration.Protocol.WPA);”，并添加“

config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP); config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);“这两句，否则当wifi热点需要输入密码时，无法加入网络。

（3）在代码末尾添加了方法IsExsits，原因在于如果按照网上介绍的方法成功加入指定的wifi后，都会在终端的wifi列表中新添加一个以该指定ssid的网络，所以每运行一次程序，列表中就会多一个相同名字的ssid。而该方法就是检查wifi列表中是否有以输入参数为名的wifi热点，如果存在，则在CreateWifiInfo方法开始配置wifi网络之前将其移除，以避免ssid的重复：

WifiConfiguration tempConfig = this.IsExsits(SSID);           

          if(tempConfig != null) {  

          mWifiManager.removeNetwork(tempConfig.networkId);  

          }

以上便是wifi工具类的建立，之后就可以在其他部分实例化这个类，调用其中的方法完成加入指定ssid的wifi热点，还是先上代码吧，建立一个名为Test_wifiActivity.java的文件（同上，没有包含包声明和import语句）：

[java] view plaincopy
  1. public class Test_wifiActivity extends Activity {  
  2.     /** Called when the activity is first created. */  
  3.     @Override  
  4.     public void onCreate(Bundle savedInstanceState) {  
  5.         super.onCreate(savedInstanceState);  
  6.         setContentView(R.layout.main);  
  7.           
  8.         WifiAdmin wifiAdmin = new WifiAdmin(this);  
  9.         wifiAdmin.openWifi();  
  10.         wifiAdmin.addNetwork(wifiAdmin.CreateWifiInfo("XXX", "XXX", 3));  
  11.     }  
  12. }  

很简单，如果是接入wifi，大体上只涉及到openWifi(打开wifi)、CreateWifiInfo(配置wifi网络信息)和addNetwork（添加配置好的网络并连接），对CreateWifiInfo进行简单的说明：第一参数是SSID的名称；第二个参数是指定SSID网络的密码，当不需要密码是置空（”“）；第三个参数是热点类型：1-无密码 / 2-WEP密码验证（未测试）/ 3-WAP或WAP2 PSK密码验证。

最后就是在Manifest中添加相应的权限了：

[java] view plaincopy
  1. <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" ></uses-permission>  
  2.     <uses-permission android:name="android.permission.CHANGE_WIFI_STATE" ></uses-permission>  
  3.     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" ></uses-permission>  
  4.     <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" ></uses-permission>  

如果按照上述的方法进行开发，就可以很傻瓜的通过改变Test_wifiActivity.java中的CreateWifiInfo方法的三个入口参数实现加入指定SSID的wifi热点了，无论该热点是否需要密码认证。

以上就是我对于自动连接指定SSID的wifi热点的学习心得，由于水平有限有些地方可能介绍错误，希望大家多多批评指正！

上一篇：mac 10.9.4下配置apache


下一篇：Tomcat服务器java.lang.IllegalArgumentException异常