android wifi 相关方面整理

在android中。 管理wifi的管理器就是 WifiManager了。所以直接从
WifiManager说起。

1.WifiManager

 context.getSystemService(Context.WIFI_SERVICE)//得到 WifiManager     


 setWifiEnabled(true)   //打开wifi
 setWifiEnabled(false)  //关闭wifi
 isWifiEnabled()        //wifi是否可用
 getWifiState()         //得到wifi状态
 getConfiguredNetworks()  //得到配置好的wifi配置
 getConnectionInfo()     得到链接的wifi信息（WifiInfo）

 startScan();       //WifiManager开始扫描方法
 getScanResults()   //得到扫描周围wifi结果（List<ScanResult>）
 addNetwork(config)           //添加网络配置 下面会说明参数
 enableNetwork(int netID ,boolean b) // 指定链接哪个网络 
 disableNetwork(int netId)      //指定断开哪个网络


calculateSignalLevel(int rssi,int numLevels)// 计算信号的等级
removeNetwork() //移除某一个网络
getDhcpInfo() //获取DHCP 的信息
calculateSignalLevel(int rssi,int numLevels)//计算信号的等级
compareSignalLevel(int rssiA,int rssiB)//对比连接A 和连接B
updateNetwork(WifiConfiguration config) //更新一个网络连接的信息

上面 getScanResults 后得到的大致信息，扫描得到的相关附近wifi信息
SSID: mima0000, BSSID: b0:05:94:fa:93:64, capabilities: [WPA2-PSK-CCMP][ESS], level: -65, frequency: 2462
SSID: ChinaNet-unyU, BSSID:7c:60:97:03:8a:94, capabilities: [WPA-PSK-TKIP][ESS], level: -76, frequency: 2412

SSID 网络的名字，当我们搜索一个网络时，就是靠这个来区分每个不同的网络接入点。
Capabilities 网络接入的性能，这里主要是来判断网络的加密方式等。
Frequency 频率，每一个频道交互的MHz 数。
Level 等级，主要来判断网络连接的优先数。

连接网络 wifiConfiguration
WifiConfiguration.AuthAlgorthm 用来判断加密方法。
WifiConfiguration.GroupCipher 获取使用GroupCipher 的方法来进行加密。
WifiConfiguration.KeyMgmt 获取使用KeyMgmt 进行。
WifiConfiguration.PairwiseCipher 获取使用WPA 方式的加密。
WifiConfiguration.Protocol 获取使用哪一种协议进行加密。
wifiConfiguration.Status 获取当前网络的状态。
对于上述加密感兴趣的朋友，可以在网上搜索相关的内容。
设置WifiConfiguration的属性：
WifiConfiguration.AuthAlgorthm 设置加密方法。
可选参数：LEAP只用于leap,
OPEN 被wpa/wpa2需要,
SHARED需要一个静态的wep key
WifiConfiguration.GroupCipher 使用GroupCipher 的方法来进行加密。
可选参数：CCMP,TKIP,WEP104,WEP40
WifiConfiguration.KeyMgmt 键管理机制（keymanagerment），使用KeyMgmt 进行。
可选参数IEEE8021X,NONE,WPA_EAP,WPA_PSK
WifiConfiguration.PairwiseCipher 设置加密方式。
可选参数 CCMP,NONE,TKIP
WifiConfiguration.Protocol 设置一种协议进行加密。
可选参数 RSN,WPA,
wifiConfiguration.Status 设置当前网络的状态。
可选参数CURRENT,DISABLED,ENABLED,

2.WifiLock 设定wifi锁

WifiManager.createWifiLock(String name) //创建wifi锁

acquire()    // 锁定
isHeld()     //是否锁定着
release()    //解锁

3.WifiInfo 获取 wifi信息

WifiManager.getConnectionInfo()  //得到WifiInfo


getBSSID() //获取BSSID   
/**
  *   BSS是一种特殊的Ad-hoc LAN的应用，一个无线网络至少由一个连接到有线网络的AP和若干无线工作站组成，这种配置称为一个基本服务装置BSS (Basic Service Set)。
  *   一群计算机设定相同的BSS名称，即可自成一个group，而此BSS名称，即所谓BSSID。
  *   通常，手机WLAN中，bssid其实就是无线路由的MAC地址. ESSID 也可认为是SSID, WIFI 网络名
  */
getDetailedStateOf() //获取客户端的连通性
getHiddenSSID()  //获得SSID 是否被隐藏
getIpAddress()   // 获取IP 地址
getLinkSpeed()   //获得连接的速度
getMacAddress()  //获得Mac 地址
getRssi()  //获得802.11n 网络的信号
getSSID()  // 获得SSID

/**    SSID（Service Set Identifier）AP唯一的ID码，用来区分不同的网络，最多可以有32个字符，
  *    无线终端和AP的SSID必须相同方可通信。无线网卡设置了不同的SSID就可以进入不同网络，SSID通常由AP广播出来，
  *    通过XP自带的扫描功能可以相看当前区域内的SSID。出于安全考虑可以不广播SSID，此时用户就要手工设置SSID才能进入相应的网络。
  *    简单说，SSID就是一个局域网的名称，只有设置为名称相同SSID的值的电脑才能互相通信。
  */
//  getSupplicanState() 返回具体客户端状态的信息  

4.下面的是一个网上的示例代码（类似一个工具类，有相应很全的一些方法）
功能
1. 打开关闭wifi
2. 扫描并能查看周围wifi信息
3. 查看本身wifi链接配置信息
4. 链接指定wifi（根据netID 链接本身配置过的，根据SSID，pwd链接新扫描出来的）

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;

public class WifiAdmin {

    // 定义WifiManager对象   
    private WifiManager mWifiManager;  
    // 定义WifiInfo对象   
    private WifiInfo mWifiInfo;  
    // 扫描出的网络连接列表   
    private List<ScanResult> mWifiList;  
    // 网络连接列表   
    private List<WifiConfiguration> mWifiConfiguration;  
    // 定义一个WifiLock   
    WifiLock mWifiLock;  


    public WifiAdmin(Context context) {  
        // 取得WifiManager  WifiInfo
      mWifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);  
      mWifiInfo = mWifiManager.getConnectionInfo();  
    }  


    // 打开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();  
    }  

    /**
     * 扫描===============================================
     * 
     * SSID: mima0000, BSSID: b0:05:94:fa:93:64, capabilities: [WPA2-PSK-CCMP][ESS], level: -65, frequency: 2462
     * SSID: ChinaNet-unyU, BSSID:7c:60:97:03:8a:94, capabilities: [WPA-PSK-TKIP][ESS], level: -76, frequency: 2412
     */
    public void startScan() {  
        System.out.println("====开始扫描====");
        mWifiManager.startScan();  
        // 得到扫描结果   
        mWifiList = mWifiManager.getScanResults();  
        // 得到配置好的网络连接   
        mWifiConfiguration = mWifiManager.getConfiguredNetworks();  
    }  
    // 查看扫描结果   
    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");  
        }  
        System.out.println("======扫描结果==="+ stringBuilder);
        return stringBuilder;  
    } 
    // 得到网络列表   
    public List<ScanResult> getWifiList() {  
        return mWifiList;  
    } 
    // 得到配置好的网络   
    public List<WifiConfiguration> getConfiguration() {  
        return mWifiConfiguration;  
    }  
    // 指定配置好的网络进行连接   
    public void connectConfiguration(int index) {  
        // 索引大于配置好的网络索引返回   
        if (index > mWifiConfiguration.size()) {  
            return;  
        }  
        // 连接配置好的指定ID的网络   mWifiManager.enableNetwork(mWifiConfiguration.get(index).networkId,  
                true);  
    }  



    /**
     * 创建wifilock========================================
     */ 
    public void creatWifiLock() {  
        mWifiLock = mWifiManager.createWifiLock("Test");  
    }
    // 锁定WifiLock   
    public void acquireWifiLock() {  
        mWifiLock.acquire();  
    }  
    // 解锁WifiLock   
    public void releaseWifiLock() {  
        // 判断时候锁定   
        if (mWifiLock.isHeld()) {  
            mWifiLock.release();  
        }  
    }  



    // 得到MAC地址   
    public String getMacAddress() {  
        return (mWifiInfo == null) ? "NULL" : mWifiInfo.getMacAddress();  
    }  
    // 得到接入点的BSSID   
    public String getBSSID() {  
        return (mWifiInfo == null) ? "NULL" : mWifiInfo.getBSSID();  
    }  

    // 得到IP地址   
    public int getIPAddress() {  
        return (mWifiInfo == null) ? 0 : mWifiInfo.getIpAddress();  
    }  

    // 得到连接的ID   
    public int getNetworkId() {  
        return (mWifiInfo == null) ? 0 : mWifiInfo.getNetworkId();  
    }  
    // 断开指定ID的网络   
    public void disconnectWifi(int netId) {  
        mWifiManager.disableNetwork(netId);  
        mWifiManager.disconnect();  
    }

    // 得到WifiInfo的所有信息包   
    public String getWifiInfo() {  
        return (mWifiInfo == null) ? "NULL" : mWifiInfo.toString();  
    }  




    // 添加一个网络并连接   
    public void addNetwork(WifiConfiguration config) { 
       int wcgID = mWifiManager.addNetwork(config);  
       boolean b =  mWifiManager.enableNetwork(wcgID, true);  
       System.out.println("a--" + wcgID); 
       System.out.println("b--" + b); 
    }  


    public WifiConfiguration CreateWifiInfo(String SSID, String Password, int Type){  
           //清空wificonfig
           WifiConfiguration config = new WifiConfiguration();    
           config.allowedAuthAlgorithms.clear();  
           config.allowedGroupCiphers.clear();  
           config.allowedKeyManagement.clear();  
           config.allowedPairwiseCiphers.clear();  
           config.allowedProtocols.clear();  
           config.SSID = "\"" + SSID + "\""; //wifi名称   

           WifiConfiguration tempConfig = this.IsExsits(SSID);            
           if(tempConfig != null) {   
              mWifiManager.removeNetwork(tempConfig.networkId);   
           } 

           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;  
    }  



     private WifiConfiguration IsExsits(String SSID){   
        List<WifiConfiguration> existingConfigs = mWifiManager.getConfiguredNetworks();   
           for (WifiConfiguration existingConfig : existingConfigs){   
             if (existingConfig.SSID.equals("\""+SSID+"\"")){   
                 return existingConfig;   
             }   
           }   
        return null;    
    } 
} 

5.当然咯，用到了wifi ，可能程序会需要在 wifi有网没网的情况下进行一些操作，类似断线重连，界面显示的不同，这就需要监听wifi的状态辣

public class WifiReceiver extends BroadcastReceiver{  
    @Override  
    public void onReceive(Context context, Intent intent) {  

if(intent.getAction().equals(WifiManager.RSSI_CHANGED_ACTION)){  

}else if(intent.getAction().equals(
           WifiManager.NETWORK_STATE_CHANGED_ACTION)){
           //wifi网络变化 
            System.out.println("网络状态改变");  
NetworkInfo info =intent.
getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);  
            if(info.getState().equals(NetworkInfo.State.DISCONNECTED)){  
     //网络断开了
 }else if(info.getState().equals(NetworkInfo.State.CONNECTED)){  
     //网络连接上了       
 WifiManager wifiManager = (WifiManager)context.getSystemService(
           Context.WIFI_SERVICE);  
 WifiInfo wifiInfo = wifiManager.getConnectionInfo();                  

      //获取当前wifi名称  
 System.out.println("连接到网络 " + wifiInfo.getSSID());  

  }  
 }else if(intent.getAction().equals(
               WifiManager.WIFI_STATE_CHANGED_ACTION)){
      //wifi打开与否  
 int wifistate = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE, 0);  

            if(wifistate == WifiManager.WIFI_STATE_DISABLED){  
                System.out.println("wifi关闭了");  
            }  
            else if(wifistate == WifiManager.WIFI_STATE_ENABLED){  
                System.out.println("wifi开启中");  
            }  
        }  
    }  
}  






//配置文件receiver intetfilter

<intent-filter >
    <action android:name="android.net.wifi.RSSI_CHANGED"/>
    <action android:name="android.net.wifi.STATE_CHANGE"/>
    <action android:name="android.net.wifi.WIFI_STATE_CHANGED"/>
</intent-filter>

6. wifi方面的权限

 <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" ></uses-permission> 
    <uses-permission android:name="android.permission.CHANGE_WIFI_STATE" ></uses-permission> 
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" ></uses-permission> 
    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" ></uses-permission>