[android学习篇][wifi java接口] wifiManager[2]　一篇博客分享

http://blog.csdn.net/u010499721/article/details/43890971

        } else if (type == WifiCipherType.WIFICIPHER_WEP) {  //  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;  
        } else if (type == WifiCipherType.WIFICIPHER_WPA) {   // 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;  
    }  





最后奉上本人毕业设计的wifi工具类：
[java] view plain copy print?
package com.ping.wifiPwd.utils;  
  
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;  
import com.ping.wifiPwd.entity.NetWork;  
import com.stericson.RootTools.RootTools;  
  
import java.util.ArrayList;  
import java.util.List;  
  
/** 
 * Created by Administrator on 2015/1/2 0002. 
 */  
public class WifiAdmin {  
    private static final String TAG = "WifiAdmin";  
    // 定义WifiManager对象  
    private WifiManager mWifiManager;  
    // 扫描出的网络连接列表  
    private List<ScanResult> mWifiList;  
    // 网络连接列表  
    private List<WifiConfiguration> mWifiConfiguration;  
    // 定义一个WifiLock  
    WifiManager.WifiLock mWifiLock;  
  
  
    // 定义几种加密方式，一种是WEP，一种是WPA，还有没有密码的情况  
    public enum WifiCipherType {  
        WIFICIPHER_WEP, WIFICIPHER_WPA, WIFICIPHER_NOPASS, WIFICIPHER_INVALID  
    }  
  
    // 构造器  
    public WifiAdmin(Context context) {  
        // 取得WifiManager对象  
        mWifiManager = (WifiManager) context  
                .getSystemService(Context.WIFI_SERVICE);  
    }  
  
    // 打开WIFI  
    public void openWifi() {  
        if (!mWifiManager.isWifiEnabled()) {  
            mWifiManager.setWifiEnabled(true);  
        }  
    }  
  
    // 关闭WIFI  
    public void closeWifi() {  
        if (mWifiManager.isWifiEnabled()) {  
            mWifiManager.setWifiEnabled(false);  
        }  
    }  
  
    // 检查当前WIFI状态  
    public int checkState() {  
        return mWifiManager.getWifiState();  
    }  
  
    public WifiManager getWifiManager (){  
        return mWifiManager;  
    }  
  
    // 锁定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 void startScan() {  
        mWifiManager.startScan();  
        // 得到扫描结果  
        mWifiList = mWifiManager.getScanResults();  
        // 得到配置好的网络连接  
        mWifiConfiguration = mWifiManager.getConfiguredNetworks();  
    }  
  
    //获取连接过的wifi信息  
    public List<WifiConfiguration> getLinkList() {  
       return mWifiManager.getConfiguredNetworks();  
    }  
  
    // 得到网络列表  
    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() {  
        // 取得WifiInfo对象  
        WifiInfo mWifiInfo = mWifiManager.getConnectionInfo();  
        return (mWifiInfo == null) ? "NULL" : mWifiInfo.getMacAddress();  
    }  
  
    // 得到接入点的SSID  
    public String getSSID() {  
        // 取得WifiInfo对象  
        WifiInfo mWifiInfo = mWifiManager.getConnectionInfo();  
        return (mWifiInfo == null) ? "NULL" : mWifiInfo.getSSID();  
    }  
  
    // 得到接入点的BSSID  
    public String getBSSID() {  
        // 取得WifiInfo对象  
        WifiInfo mWifiInfo = mWifiManager.getConnectionInfo();  
        return (mWifiInfo == null) ? "NULL" : mWifiInfo.getBSSID();  
    }  
  
    // 得到IP地址  
    public int getIPAddress()  
    {  
        // 取得WifiInfo对象  
        WifiInfo mWifiInfo = mWifiManager.getConnectionInfo();  
        return (mWifiInfo == null) ? 0 : mWifiInfo.getIpAddress();  
    }  
  
    // 得到连接的ID  
    public int getNetworkId() {  
        // 取得WifiInfo对象  
        WifiInfo mWifiInfo = mWifiManager.getConnectionInfo();  
        return (mWifiInfo == null) ? 0 : mWifiInfo.getNetworkId();  
    }  
  
    // 得到WifiInfo的所有信息包  
    public String getWifiInfo() {  
        // 取得WifiInfo对象  
        WifiInfo mWifiInfo = mWifiManager.getConnectionInfo();  
        return (mWifiInfo == null) ? "NULL" : mWifiInfo.toString();  
    }  
  
    // 添加一个网络并连接  
    public boolean addNetwork(WifiConfiguration wcg) {  
        int wcgID = mWifiManager.addNetwork(wcg);  
        boolean b =  mWifiManager.enableNetwork(wcgID, true);  
        System.out.println("a--" + wcgID);  
        System.out.println("b--" + b);  
        return b;  
    }  
  
    // 断开指定ID的网络  
    public void disconnectWifi(int netId) {  
        mWifiManager.disableNetwork(netId);  
        mWifiManager.disconnect();  
    }  
  
//然后是一个实际应用方法，只验证过没有密码的情况：  
  
    public WifiConfiguration createWifiInfo(String SSID, String password, WifiCipherType type) {  
  
        Log.v(TAG, "SSID = " + SSID + "## Password = " + password + "## Type = " + type);  
  
        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.isExsits(SSID);  
        if (tempConfig != null) {  
            mWifiManager.removeNetwork(tempConfig.networkId);  
        }  
  
        // 分为三种情况：1没有密码2用wep加密3用wpa加密  
        if (type == WifiCipherType.WIFICIPHER_NOPASS) {// WIFICIPHER_NOPASS  
            config.wepKeys[0] = "";  
            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);  
            config.wepTxKeyIndex = 0;  
  
        } else if (type == WifiCipherType.WIFICIPHER_WEP) {  //  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;  
        } else if (type == WifiCipherType.WIFICIPHER_WPA) {   // 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 WifiConfiguration getWifiConfig(String SSID)  
    {  
        List<WifiConfiguration> existingConfigs = mWifiManager.getConfiguredNetworks();  
        for (WifiConfiguration existingConfig : existingConfigs)  
        {  
            if (existingConfig.SSID.equals("/"+SSID+"/"))  
            {  
                return existingConfig;  
            }  
        }  
        return null;  
    }  
  
    public boolean delWifi(String ssid) {  
        WifiConfiguration tempConfig = isExsits(ssid);  
  
        if (tempConfig != null) {  
//            wifiManager.enableNetwork(tempConfig.networkId,false);//无效  
            tempConfig.hiddenSSID = true;  
            tempConfig.wepKeys[0]= "\"" + "1234" + "\"";  
            tempConfig.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.SHARED);  
            tempConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);  
            tempConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);  
            tempConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);  
            tempConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP104);  
            tempConfig.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);  
            tempConfig.wepTxKeyIndex = 0;  
  
            //tempConfig.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);  
            //tempConfig.hiddenSSID = true;  
            mWifiManager.updateNetwork(tempConfig);  
            mWifiManager.removeNetwork(tempConfig.networkId);  
            return  true;  
        }  
  
        return false;  
    }  
  
    // 查看以前是否也配置过这个网络  
    public 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,WifiCipherType type){  
        WifiConfiguration wifiConfiguration = createWifiInfo(ssid,password,type);  
        if (wifiConfiguration==null ){  
            return false;  
        }  
        return addNetwork(wifiConfiguration);  
  
  
  
//        try {  
//            WifiConfiguration wifiConfig = createWifiInfo(ssid, password, type);  
//            //  
//            if (wifiConfig == null) {  
//                Log.d(TAG, "wifiConfig is null!");  
//                return false;  
//            }  
//  
////            WifiConfiguration tempConfig = getWifiConfig(ssid);  
////            if (tempConfig != null) {  
////                mWifiManager.removeNetwork(tempConfig.networkId);  
////            }  
//  
//            int netID = mWifiManager.addNetwork(wifiConfig);  
//            Log.d(TAG,"net id:" + netID);  
//            boolean enabled = mWifiManager.enableNetwork(netID, true);  
//            Log.d(TAG, "enableNetwork status enable=" + enabled);  
//            boolean connected = mWifiManager.reconnect();  
//            Log.d(TAG, "enableNetwork connected=" + connected);  
//            if (netID==-1) {  
//                return false;  
//            }  
//        } catch (Exception e) {  
//            e.printStackTrace();  
//            Log.e(TAG,e.getMessage());  
//            return false;  
//        }  
//        return true;  
    }  
  
    private static boolean isHexWepKey(String wepKey) {  
        final int len = wepKey.length();  
  
        // WEP-40, WEP-104, and some vendors using 256-bit WEP (WEP-232?)  
        if (len != 10 && len != 26 && len != 58) {  
            return false;  
        }  
  
        return isHex(wepKey);  
    }  
  
    private static boolean isHex(String key) {  
        for (int i = key.length() - 1; i >= 0; i--) {  
            final char c = key.charAt(i);  
            if (!(c >= '0' && c <= '9' || c >= 'A' && c <= 'F' || c >= 'a' && c <= 'f')) {  
                return false;  
            }  
        }  
        return true;  
    }  
  
  
    //增加部分  
    private static StringBuffer header;  
    private static NetWork temp;  
    public static List<NetWork> listAllWifiDate () {  
        LogUtil.w("test","listallwifi@@");  
        try {  
            List<String> strs = RootTools.sendShell("cat data/misc/wifi/wpa_supplicant.conf", 31000);  
            if (strs==null) return null;  
  
            header = new StringBuffer();  
            List<NetWork> list = new ArrayList<NetWork>();  
            boolean isStarted = false;  
            for (String line :strs) {  
                if (line==null) {continue;}  
                //Log.w("test","line:" + line);  
  
                if (line.replace(" ","").equals("network={")) {  
                    isStarted  = true;  
                    temp = new NetWork();  
//                    temp.setLatitude(APPLocation.getLatitude(null));  
//                    temp.setLontitude(APPLocation.getLontitude(null));  
//                    temp.setAddr(APPLocation.getAddress(null));  
                } else if (line.replace(" ","").equals("}")) {  
                    isStarted = false;  
                    list.add(temp);  
                } else if (isStarted) {  
                    String[] kv = line.trim().split("=");  
                    if (kv.length>1) {  
                        String key = kv[0];  
                        String value = kv[1];  
  
                        if (value!=null) {  
                            value = value.trim();  
                            if (value.length()>2) {  
                                if (value.charAt(0)=='"') {  
                                    value = value.substring(1,value.length()-1);  
                                }  
                                if (value.charAt(value.length()-1)=='"') {  
                                    value = value.substring(0,value.length()-2);  
                                }  
                            }  
                        }  
  
                        if (key.equals("ssid")) {  
                            temp.setSsid(value);  
                        } else if (key.equals("key_mgmt")) {  
                            temp.setKey_mgmt(value);  
                        } else if (key.equals("psk")) {  
                            temp.setPsk(value);  
                            temp.setShowpsk(getShowPsk(value));  
                        } else if (key.equals("priority")) {  
                            temp.setPriority(value);  
                        } else if (key.equals("auth_alg")) {  
                            temp.setAuth_alg(value);  
                        } else if (key.equals("eapol_flag")) {  
                            temp.setEapol_flags(value);  
                        } else if (key.equals("group")) {  
                            temp.setGroup(value);  
                        } else if (key.equals("pairwise")) {  
                            temp.setPairwise(value);  
                        } else if (key.equals("proto")) {  
                            temp.setProto(value);  
                        } else if (key.equals("private_key")) {  
                            temp.setPrivate_key(value);  
                        } else {  
                            //Log.i("test","error:"  + key + ">>" + value);  
                        }  
                    }  
                } else if (!isStarted){  
                    header.append(line + "\n");  
                }  
            }  
  
            return list;  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
        return null;  
    }  
  
    public static String getShowPsk(String psk) {  
        if (psk==null) {  
            return "";  
        }  
        char head=0,end = 0;  
        int len;  
        if (psk.length() > 2) {  
            head = psk.charAt(0);  
            end = psk.charAt(psk.length()-1);  
  
            len = psk.length()-2;  
        } else{  
            len = psk.length();  
        }  
  
        StringBuffer sb = new StringBuffer();  
        if (head!=0)  
            sb.append(head);  
  
        for (int i=0;i<len;i++) {  
            sb.append("*");  
        }  
  
  
        if (end!=0)  
            sb.append(end);  
  
        return sb.toString();  
    }  
  
  
  
  
  
  
}

 

 

  1.         } else if (type == WifiCipherType.WIFICIPHER_WEP) {  //  WIFICIPHER_WEP  
  2.             config.hiddenSSID = true;  
  3.             config.wepKeys[0] = "\"" + password + "\"";  
  4.             config.allowedAuthAlgorithms  
  5.                     .set(WifiConfiguration.AuthAlgorithm.SHARED);  
  6.             config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);  
  7.             config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);  
  8.             config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);  
  9.             config.allowedGroupCiphers  
  10.                     .set(WifiConfiguration.GroupCipher.WEP104);  
  11.             config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);  
  12.             config.wepTxKeyIndex = 0;  
  13.         } else if (type == WifiCipherType.WIFICIPHER_WPA) {   // WIFICIPHER_WPA  
  14.             config.preSharedKey = "\"" + password + "\"";  
  15.             config.hiddenSSID = true;  
  16.             config.allowedAuthAlgorithms  
  17.                     .set(WifiConfiguration.AuthAlgorithm.OPEN);  
  18.             config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);  
  19.             config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);  
  20.             config.allowedPairwiseCiphers  
  21.                     .set(WifiConfiguration.PairwiseCipher.TKIP);  
  22.             // config.allowedProtocols.set(WifiConfiguration.Protocol.WPA);  
  23.             config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);  
  24.             config.allowedPairwiseCiphers  
  25.                     .set(WifiConfiguration.PairwiseCipher.CCMP);  
  26.             config.status = WifiConfiguration.Status.ENABLED;  
  27.         }  
  28.   
  29.         return config;  
  30.     }  


 



 

最后奉上本人毕业设计的wifi工具类：

 

[java] view plain copy
 
 print?
  1. package com.ping.wifiPwd.utils;  
  2.   
  3. import android.content.Context;  
  4. import android.net.wifi.ScanResult;  
  5. import android.net.wifi.WifiConfiguration;  
  6. import android.net.wifi.WifiInfo;  
  7. import android.net.wifi.WifiManager;  
  8. import android.text.TextUtils;  
  9. import android.util.Log;  
  10. import com.ping.wifiPwd.entity.NetWork;  
  11. import com.stericson.RootTools.RootTools;  
  12.   
  13. import java.util.ArrayList;  
  14. import java.util.List;  
  15.   
  16. /** 
  17.  * Created by Administrator on 2015/1/2 0002. 
  18.  */  
  19. public class WifiAdmin {  
  20.     private static final String TAG = "WifiAdmin";  
  21.     // 定义WifiManager对象  
  22.     private WifiManager mWifiManager;  
  23.     // 扫描出的网络连接列表  
  24.     private List<ScanResult> mWifiList;  
  25.     // 网络连接列表  
  26.     private List<WifiConfiguration> mWifiConfiguration;  
  27.     // 定义一个WifiLock  
  28.     WifiManager.WifiLock mWifiLock;  
  29.   
  30.   
  31.     // 定义几种加密方式，一种是WEP，一种是WPA，还有没有密码的情况  
  32.     public enum WifiCipherType {  
  33.         WIFICIPHER_WEP, WIFICIPHER_WPA, WIFICIPHER_NOPASS, WIFICIPHER_INVALID  
  34.     }  
  35.   
  36.     // 构造器  
  37.     public WifiAdmin(Context context) {  
  38.         // 取得WifiManager对象  
  39.         mWifiManager = (WifiManager) context  
  40.                 .getSystemService(Context.WIFI_SERVICE);  
  41.     }  
  42.   
  43.     // 打开WIFI  
  44.     public void openWifi() {  
  45.         if (!mWifiManager.isWifiEnabled()) {  
  46.             mWifiManager.setWifiEnabled(true);  
  47.         }  
  48.     }  
  49.   
  50.     // 关闭WIFI  
  51.     public void closeWifi() {  
  52.         if (mWifiManager.isWifiEnabled()) {  
  53.             mWifiManager.setWifiEnabled(false);  
  54.         }  
  55.     }  
  56.   
  57.     // 检查当前WIFI状态  
  58.     public int checkState() {  
  59.         return mWifiManager.getWifiState();  
  60.     }  
  61.   
  62.     public WifiManager getWifiManager (){  
  63.         return mWifiManager;  
  64.     }  
  65.   
  66.     // 锁定WifiLock  
  67.     public void acquireWifiLock() {  
  68.         mWifiLock.acquire();  
  69.     }  
  70.   
  71.     // 解锁WifiLock  
  72.     public void releaseWifiLock() {  
  73.         // 判断时候锁定  
  74.         if (mWifiLock.isHeld()) {  
  75.             mWifiLock.acquire();  
  76.         }  
  77.     }  
  78.   
  79.     // 创建一个WifiLock  
  80.     public void creatWifiLock() {  
  81.         mWifiLock = mWifiManager.createWifiLock("Test");  
  82.     }  
  83.   
  84.     // 得到配置好的网络  
  85.     public List<WifiConfiguration> getConfiguration() {  
  86.         return mWifiConfiguration;  
  87.     }  
  88.   
  89.     // 指定配置好的网络进行连接  
  90.     public void connectConfiguration(int index) {  
  91.         // 索引大于配置好的网络索引返回  
  92.         if (index > mWifiConfiguration.size()) {  
  93.             return;  
  94.         }  
  95.         // 连接配置好的指定ID的网络  
  96.         mWifiManager.enableNetwork(mWifiConfiguration.get(index).networkId,  
  97.                 true);  
  98.     }  
  99.   
  100.     public void startScan() {  
  101.         mWifiManager.startScan();  
  102.         // 得到扫描结果  
  103.         mWifiList = mWifiManager.getScanResults();  
  104.         // 得到配置好的网络连接  
  105.         mWifiConfiguration = mWifiManager.getConfiguredNetworks();  
  106.     }  
  107.   
  108.     //获取连接过的wifi信息  
  109.     public List<WifiConfiguration> getLinkList() {  
  110.        return mWifiManager.getConfiguredNetworks();  
  111.     }  
  112.   
  113.     // 得到网络列表  
  114.     public List<ScanResult> getWifiList() {  
  115.         return mWifiList;  
  116.     }  
  117.   
  118.     // 查看扫描结果  
  119.     public StringBuilder lookUpScan() {  
  120.         StringBuilder stringBuilder = new StringBuilder();  
  121.         for (int i = 0; i < mWifiList.size(); i++) {  
  122.             stringBuilder  
  123.                     .append("Index_" + new Integer(i + 1).toString() + ":");  
  124.             // 将ScanResult信息转换成一个字符串包  
  125.             // 其中把包括：BSSID、SSID、capabilities、frequency、level  
  126.             stringBuilder.append((mWifiList.get(i)).toString());  
  127.             stringBuilder.append("/n");  
  128.         }  
  129.         return stringBuilder;  
  130.     }  
  131.   
  132.     // 得到MAC地址  
  133.     public String getMacAddress() {  
  134.         // 取得WifiInfo对象  
  135.         WifiInfo mWifiInfo = mWifiManager.getConnectionInfo();  
  136.         return (mWifiInfo == null) ? "NULL" : mWifiInfo.getMacAddress();  
  137.     }  
  138.   
  139.     // 得到接入点的SSID  
  140.     public String getSSID() {  
  141.         // 取得WifiInfo对象  
  142.         WifiInfo mWifiInfo = mWifiManager.getConnectionInfo();  
  143.         return (mWifiInfo == null) ? "NULL" : mWifiInfo.getSSID();  
  144.     }  
  145.   
  146.     // 得到接入点的BSSID  
  147.     public String getBSSID() {  
  148.         // 取得WifiInfo对象  
  149.         WifiInfo mWifiInfo = mWifiManager.getConnectionInfo();  
  150.         return (mWifiInfo == null) ? "NULL" : mWifiInfo.getBSSID();  
  151.     }  
  152.   
  153.     // 得到IP地址  
  154.     public int getIPAddress()  
  155.     {  
  156.         // 取得WifiInfo对象  
  157.         WifiInfo mWifiInfo = mWifiManager.getConnectionInfo();  
  158.         return (mWifiInfo == null) ? 0 : mWifiInfo.getIpAddress();  
  159.     }  
  160.   
  161.     // 得到连接的ID  
  162.     public int getNetworkId() {  
  163.         // 取得WifiInfo对象  
  164.         WifiInfo mWifiInfo = mWifiManager.getConnectionInfo();  
  165.         return (mWifiInfo == null) ? 0 : mWifiInfo.getNetworkId();  
  166.     }  
  167.   
  168.     // 得到WifiInfo的所有信息包  
  169.     public String getWifiInfo() {  
  170.         // 取得WifiInfo对象  
  171.         WifiInfo mWifiInfo = mWifiManager.getConnectionInfo();  
  172.         return (mWifiInfo == null) ? "NULL" : mWifiInfo.toString();  
  173.     }  
  174.   
  175.     // 添加一个网络并连接  
  176.     public boolean addNetwork(WifiConfiguration wcg) {  
  177.         int wcgID = mWifiManager.addNetwork(wcg);  
  178.         boolean b =  mWifiManager.enableNetwork(wcgID, true);  
  179.         System.out.println("a--" + wcgID);  
  180.         System.out.println("b--" + b);  
  181.         return b;  
  182.     }  
  183.   
  184.     // 断开指定ID的网络  
  185.     public void disconnectWifi(int netId) {  
  186.         mWifiManager.disableNetwork(netId);  
  187.         mWifiManager.disconnect();  
  188.     }  
  189.   
  190. //然后是一个实际应用方法，只验证过没有密码的情况：  
  191.   
  192.     public WifiConfiguration createWifiInfo(String SSID, String password, WifiCipherType type) {  
  193.   
  194.         Log.v(TAG, "SSID = " + SSID + "## Password = " + password + "## Type = " + type);  
  195.   
  196.         WifiConfiguration config = new WifiConfiguration();  
  197.         config.allowedAuthAlgorithms.clear();  
  198.         config.allowedGroupCiphers.clear();  
  199.         config.allowedKeyManagement.clear();  
  200.         config.allowedPairwiseCiphers.clear();  
  201.         config.allowedProtocols.clear();  
  202.         config.SSID = "\"" + SSID + "\"";  
  203.   
  204.         WifiConfiguration tempConfig = this.isExsits(SSID);  
  205.         if (tempConfig != null) {  
  206.             mWifiManager.removeNetwork(tempConfig.networkId);  
  207.         }  
  208.   
  209.         // 分为三种情况：1没有密码2用wep加密3用wpa加密  
  210.         if (type == WifiCipherType.WIFICIPHER_NOPASS) {// WIFICIPHER_NOPASS  
  211.             config.wepKeys[0] = "";  
  212.             config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);  
  213.             config.wepTxKeyIndex = 0;  
  214.   
  215.         } else if (type == WifiCipherType.WIFICIPHER_WEP) {  //  WIFICIPHER_WEP  
  216.             config.hiddenSSID = true;  
  217.             config.wepKeys[0] = "\"" + password + "\"";  
  218.             config.allowedAuthAlgorithms  
  219.                     .set(WifiConfiguration.AuthAlgorithm.SHARED);  
  220.             config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);  
  221.             config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);  
  222.             config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);  
  223.             config.allowedGroupCiphers  
  224.                     .set(WifiConfiguration.GroupCipher.WEP104);  
  225.             config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);  
  226.             config.wepTxKeyIndex = 0;  
  227.         } else if (type == WifiCipherType.WIFICIPHER_WPA) {   // WIFICIPHER_WPA  
  228.             config.preSharedKey = "\"" + password + "\"";  
  229.             config.hiddenSSID = true;  
  230.             config.allowedAuthAlgorithms  
  231.                     .set(WifiConfiguration.AuthAlgorithm.OPEN);  
  232.             config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);  
  233.             config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);  
  234.             config.allowedPairwiseCiphers  
  235.                     .set(WifiConfiguration.PairwiseCipher.TKIP);  
  236.             // config.allowedProtocols.set(WifiConfiguration.Protocol.WPA);  
  237.             config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);  
  238.             config.allowedPairwiseCiphers  
  239.                     .set(WifiConfiguration.PairwiseCipher.CCMP);  
  240.             config.status = WifiConfiguration.Status.ENABLED;  
  241.         }  
  242.   
  243.         return config;  
  244.     }  
  245.   
  246.     public WifiConfiguration getWifiConfig(String SSID)  
  247.     {  
  248.         List<WifiConfiguration> existingConfigs = mWifiManager.getConfiguredNetworks();  
  249.         for (WifiConfiguration existingConfig : existingConfigs)  
  250.         {  
  251.             if (existingConfig.SSID.equals("/"+SSID+"/"))  
  252.             {  
  253.                 return existingConfig;  
  254.             }  
  255.         }  
  256.         return null;  
  257.     }  
  258.   
  259.     public boolean delWifi(String ssid) {  
  260.         WifiConfiguration tempConfig = isExsits(ssid);  
  261.   
  262.         if (tempConfig != null) {  
  263. //            wifiManager.enableNetwork(tempConfig.networkId,false);//无效  
  264.             tempConfig.hiddenSSID = true;  
  265.             tempConfig.wepKeys[0]= "\"" + "1234" + "\"";  
  266.             tempConfig.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.SHARED);  
  267.             tempConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);  
  268.             tempConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);  
  269.             tempConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);  
  270.             tempConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP104);  
  271.             tempConfig.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);  
  272.             tempConfig.wepTxKeyIndex = 0;  
  273.   
  274.             //tempConfig.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);  
  275.             //tempConfig.hiddenSSID = true;  
  276.             mWifiManager.updateNetwork(tempConfig);  
  277.             mWifiManager.removeNetwork(tempConfig.networkId);  
  278.             return  true;  
  279.         }  
  280.   
  281.         return false;  
  282.     }  
  283.   
  284.     // 查看以前是否也配置过这个网络  
  285.     public WifiConfiguration isExsits(String SSID) {  
  286.         List<WifiConfiguration> existingConfigs = mWifiManager.getConfiguredNetworks();  
  287.         for (WifiConfiguration existingConfig : existingConfigs) {  
  288.             if (existingConfig.SSID.equals("\"" + SSID + "\"")) {  
  289.                 return existingConfig;  
  290.             }  
  291.         }  
  292.         return null;  
  293.     }  
  294.   
  295.   
  296.     public boolean connect(String ssid, String password,WifiCipherType type){  
  297.         WifiConfiguration wifiConfiguration = createWifiInfo(ssid,password,type);  
  298.         if (wifiConfiguration==null ){  
  299.             return false;  
  300.         }  
  301.         return addNetwork(wifiConfiguration);  
  302.   
  303.   
  304.   
  305. //        try {  
  306. //            WifiConfiguration wifiConfig = createWifiInfo(ssid, password, type);  
  307. //            //  
  308. //            if (wifiConfig == null) {  
  309. //                Log.d(TAG, "wifiConfig is null!");  
  310. //                return false;  
  311. //            }  
  312. //  
  313. ////            WifiConfiguration tempConfig = getWifiConfig(ssid);  
  314. ////            if (tempConfig != null) {  
  315. ////                mWifiManager.removeNetwork(tempConfig.networkId);  
  316. ////            }  
  317. //  
  318. //            int netID = mWifiManager.addNetwork(wifiConfig);  
  319. //            Log.d(TAG,"net id:" + netID);  
  320. //            boolean enabled = mWifiManager.enableNetwork(netID, true);  
  321. //            Log.d(TAG, "enableNetwork status enable=" + enabled);  
  322. //            boolean connected = mWifiManager.reconnect();  
  323. //            Log.d(TAG, "enableNetwork connected=" + connected);  
  324. //            if (netID==-1) {  
  325. //                return false;  
  326. //            }  
  327. //        } catch (Exception e) {  
  328. //            e.printStackTrace();  
  329. //            Log.e(TAG,e.getMessage());  
  330. //            return false;  
  331. //        }  
  332. //        return true;  
  333.     }  
  334.   
  335.     private static boolean isHexWepKey(String wepKey) {  
  336.         final int len = wepKey.length();  
  337.   
  338.         // WEP-40, WEP-104, and some vendors using 256-bit WEP (WEP-232?)  
  339.         if (len != 10 && len != 26 && len != 58) {  
  340.             return false;  
  341.         }  
  342.   
  343.         return isHex(wepKey);  
  344.     }  
  345.   
  346.     private static boolean isHex(String key) {  
  347.         for (int i = key.length() - 1; i >= 0; i--) {  
  348.             final char c = key.charAt(i);  
  349.             if (!(c >= '0' && c <= '9' || c >= 'A' && c <= 'F' || c >= 'a' && c <= 'f')) {  
  350.                 return false;  
  351.             }  
  352.         }  
  353.         return true;  
  354.     }  
  355.   
  356.   
  357.     //增加部分  
  358.     private static StringBuffer header;  
  359.     private static NetWork temp;  
  360.     public static List<NetWork> listAllWifiDate () {  
  361.         LogUtil.w("test","listallwifi@@");  
  362.         try {  
  363.             List<String> strs = RootTools.sendShell("cat data/misc/wifi/wpa_supplicant.conf", 31000);  
  364.             if (strs==null) return null;  
  365.   
  366.             header = new StringBuffer();  
  367.             List<NetWork> list = new ArrayList<NetWork>();  
  368.             boolean isStarted = false;  
  369.             for (String line :strs) {  
  370.                 if (line==null) {continue;}  
  371.                 //Log.w("test","line:" + line);  
  372.   
  373.                 if (line.replace(" ","").equals("network={")) {  
  374.                     isStarted  = true;  
  375.                     temp = new NetWork();  
  376. //                    temp.setLatitude(APPLocation.getLatitude(null));  
  377. //                    temp.setLontitude(APPLocation.getLontitude(null));  
  378. //                    temp.setAddr(APPLocation.getAddress(null));  
  379.                 } else if (line.replace(" ","").equals("}")) {  
  380.                     isStarted = false;  
  381.                     list.add(temp);  
  382.                 } else if (isStarted) {  
  383.                     String[] kv = line.trim().split("=");  
  384.                     if (kv.length>1) {  
  385.                         String key = kv[0];  
  386.                         String value = kv[1];  
  387.   
  388.                         if (value!=null) {  
  389.                             value = value.trim();  
  390.                             if (value.length()>2) {  
  391.                                 if (value.charAt(0)=='"') {  
  392.                                     value = value.substring(1,value.length()-1);  
  393.                                 }  
  394.                                 if (value.charAt(value.length()-1)=='"') {  
  395.                                     value = value.substring(0,value.length()-2);  
  396.                                 }  
  397.                             }  
  398.                         }  
  399.   
  400.                         if (key.equals("ssid")) {  
  401.                             temp.setSsid(value);  
  402.                         } else if (key.equals("key_mgmt")) {  
  403.                             temp.setKey_mgmt(value);  
  404.                         } else if (key.equals("psk")) {  
  405.                             temp.setPsk(value);  
  406.                             temp.setShowpsk(getShowPsk(value));  
  407.                         } else if (key.equals("priority")) {  
  408.                             temp.setPriority(value);  
  409.                         } else if (key.equals("auth_alg")) {  
  410.                             temp.setAuth_alg(value);  
  411.                         } else if (key.equals("eapol_flag")) {  
  412.                             temp.setEapol_flags(value);  
  413.                         } else if (key.equals("group")) {  
  414.                             temp.setGroup(value);  
  415.                         } else if (key.equals("pairwise")) {  
  416.                             temp.setPairwise(value);  
  417.                         } else if (key.equals("proto")) {  
  418.                             temp.setProto(value);  
  419.                         } else if (key.equals("private_key")) {  
  420.                             temp.setPrivate_key(value);  
  421.                         } else {  
  422.                             //Log.i("test","error:"  + key + ">>" + value);  
  423.                         }  
  424.                     }  
  425.                 } else if (!isStarted){  
  426.                     header.append(line + "\n");  
  427.                 }  
  428.             }  
  429.   
  430.             return list;  
  431.         } catch (Exception e) {  
  432.             e.printStackTrace();  
  433.         }  
  434.         return null;  
  435.     }  
  436.   
  437.     public static String getShowPsk(String psk) {  
  438.         if (psk==null) {  
  439.             return "";  
  440.         }  
  441.         char head=0,end = 0;  
  442.         int len;  
  443.         if (psk.length() > 2) {  
  444.             head = psk.charAt(0);  
  445.             end = psk.charAt(psk.length()-1);  
  446.   
  447.             len = psk.length()-2;  
  448.         } else{  
  449.             len = psk.length();  
  450.         }  
  451.   
  452.         StringBuffer sb = new StringBuffer();  
  453.         if (head!=0)  
  454.             sb.append(head);  
  455.   
  456.         for (int i=0;i<len;i++) {  
  457.             sb.append("*");  
  458.         }  
  459.   
  460.   
  461.         if (end!=0)  
  462.             sb.append(end);  
  463.   
  464.         return sb.toString();  
  465.     }  
  466.   
  467.   
  468.   
  469.   
  470.   
  471.   
  472. }  



 

posted @ 2017-07-20 13:30  liuzhipenglove  阅读(1315)  评论(0)    收藏  举报