ndroid 监听wifi总结

功能实现：控制wifi开关，连上某个特定的wifi。

首先先上个wifi工具类，此类转载网上一人，出处不明了。 

 package rodar.rgs.conference.utils;

 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.net.InetAddress;
 import java.util.ArrayList;
 import java.util.List;

 import android.net.wifi.ScanResult;
 import android.net.wifi.WifiConfiguration;
 import android.net.wifi.WifiManager;

 public class WifiConnect {
      WifiManager wifiManager;

     //定义几种加密方式，一种是WEP，一种是WPA，还有没有密码的情况
         public enum WifiCipherType
         {
           WIFICIPHER_WEP,WIFICIPHER_WPA, WIFICIPHER_NOPASS, WIFICIPHER_INVALID
         }

     //构造函数
         public WifiConnect(WifiManager wifiManager)
         {
           this.wifiManager = wifiManager;
         }

     //打开wifi功能
          private boolean OpenWifi()
          {
              boolean bRet = true;
              if (!wifiManager.isWifiEnabled())
              {
               bRet = wifiManager.setWifiEnabled(true);
              }
              return bRet;
          }

     //提供一个外部接口，传入要连接的无线网
          public boolean Connect(String SSID, String Password, WifiCipherType Type)
          {
             if(!this.OpenWifi())
             {
                  return false;
             }
             System.out.println(">>>wifiCon=");
     //开启wifi功能需要一段时间(我在手机上测试一般需要1-3秒左右)，所以要等到wifi
     //状态变成WIFI_STATE_ENABLED的时候才能执行下面的语句
             while(wifiManager.getWifiState() == WifiManager.WIFI_STATE_ENABLING )
             {
                  try{
          //为了避免程序一直while循环，让它睡个100毫秒在检测……
                   Thread.currentThread();
                   Thread.sleep(100);
                 }
                 catch(InterruptedException ie){
                }
             }

         WifiConfiguration wifiConfig = this.CreateWifiInfo(SSID, Password, Type);
             //
             if(wifiConfig == null)
             {
                    return false;
             }
             WifiConfiguration tempConfig = this.IsExsits(SSID);

             if(tempConfig != null)
             {
                 wifiManager.removeNetwork(tempConfig.networkId);
             }

 //          try {
 //              //高级选项
 //              String ip  ="192.168.1.201";
 //              int networkPrefixLength =24;
 //              InetAddress intetAddress  = InetAddress.getByName(ip);
 //              int intIp = inetAddressToInt(intetAddress);
 //              String dns = (intIp & 0xFF ) + "." + ((intIp >> 8 ) & 0xFF) + "." + ((intIp >> 16 ) & 0xFF) + ".1";
 //              setIpAssignment("STATIC", wifiConfig); //"STATIC" or "DHCP" for dynamic setting
 //              setIpAddress(intetAddress, networkPrefixLength, wifiConfig);
 //              setGateway(InetAddress.getByName(dns), wifiConfig);
 //              setDNS(InetAddress.getByName(dns), wifiConfig);
 //          } catch (Exception e) {
 //              // TODO: handle exception
 //              e.printStackTrace();
 //          }

             int netID = wifiManager.addNetwork(wifiConfig);
             boolean bRet = wifiManager.enableNetwork(netID, true);
 //          wifiManager.updateNetwork(wifiConfig);


             return bRet;
          }

         //查看以前是否也配置过这个网络
          private WifiConfiguration IsExsits(String SSID)
          {
              List<WifiConfiguration> existingConfigs = wifiManager.getConfiguredNetworks();
                 for (WifiConfiguration existingConfig : existingConfigs)
                 {
                   if (existingConfig.SSID.equals("\""+SSID+"\""))
                   {
                       return existingConfig;
                   }
                 }
              return null;
          }

          private WifiConfiguration CreateWifiInfo(String SSID, String Password, WifiCipherType 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 == WifiCipherType.WIFICIPHER_NOPASS)
             {
                  config.wepKeys[0] = "";
                  config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
                  config.wepTxKeyIndex = 0;
             }
             if(Type == WifiCipherType.WIFICIPHER_WEP)
             {
                 config.preSharedKey = "\""+Password+"\"";
                 config.hiddenSSID = true;
                 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 == WifiCipherType.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;
             }
             else
             {
                 return null;
             }
             return config;
          }





          /***
           * Convert a IPv4 address from an InetAddress to an integer
           * @param inetAddr is an InetAddress corresponding to the IPv4 address
           * @return the IP address as an integer in network byte order
           */
          public static int inetAddressToInt(InetAddress inetAddr)
                  throws IllegalArgumentException {
              byte [] addr = inetAddr.getAddress();
              if (addr.length != 4) {
                  throw new IllegalArgumentException("Not an IPv4 address");
              }
              return ((addr[3] & 0xff) << 24) | ((addr[2] & 0xff) << 16) |
                      ((addr[1] & 0xff) << 8) | (addr[0] & 0xff);
          }

         public static void setIpAssignment(String assign, WifiConfiguration wifiConf)throws SecurityException, IllegalArgumentException,NoSuchFieldException, IllegalAccessException {
             setEnumField(wifiConf, assign, "ipAssignment");
         }

         public static void setEnumField(Object obj, String value, String name) throws SecurityException, NoSuchFieldException,
         IllegalArgumentException, IllegalAccessException {
             Field f = obj.getClass().getField(name);
             f.set(obj, Enum.valueOf((Class<Enum>) f.getType(), value));
         }

         public static void setIpAddress(InetAddress addr, int prefixLength,WifiConfiguration wifiConf) throws SecurityException,IllegalArgumentException,
         NoSuchFieldException,IllegalAccessException, NoSuchMethodException,ClassNotFoundException, InstantiationException,InvocationTargetException {
             Object linkProperties = getField(wifiConf, "linkProperties");
             if (linkProperties == null)
                 return;
             Class laClass = Class.forName("android.net.LinkAddress");
             Constructor laConstructor = laClass.getConstructor(new Class[] {InetAddress.class, int.class });
             Object linkAddress = laConstructor.newInstance(addr, prefixLength);
             ArrayList mLinkAddresses = (ArrayList) getDeclaredField(linkProperties,"mLinkAddresses");
             mLinkAddresses.clear();
             mLinkAddresses.add(linkAddress);
         }

         public static void setGateway(InetAddress gateway,WifiConfiguration wifiConf) throws SecurityException,IllegalArgumentException,
         NoSuchFieldException,IllegalAccessException, ClassNotFoundException,NoSuchMethodException, InstantiationException,InvocationTargetException {
             Object linkProperties = getField(wifiConf, "linkProperties");
             if (linkProperties == null)
                 return;
             Class routeInfoClass = Class.forName("android.net.RouteInfo");
             Constructor routeInfoConstructor = routeInfoClass.getConstructor(new Class[] { InetAddress.class });
             Object routeInfo = routeInfoConstructor.newInstance(gateway);
             ArrayList mRoutes = (ArrayList) getDeclaredField(linkProperties,"mRoutes");
             mRoutes.clear();
             mRoutes.add(routeInfo);
         }

         public static void setDNS(InetAddress dns, WifiConfiguration wifiConf) throws SecurityException, IllegalArgumentException,NoSuchFieldException, IllegalAccessException {
             Object linkProperties = getField(wifiConf, "linkProperties");
             if (linkProperties == null)
                 return;
             ArrayList<InetAddress> mDnses = (ArrayList<InetAddress>) getDeclaredField(linkProperties, "mDnses");
             mDnses.clear(); // or add a new dns address , here I just want to replace DNS1
             mDnses.add(dns);
         }

         public static Object getField(Object obj, String name) throws SecurityException, NoSuchFieldException,IllegalArgumentException, IllegalAccessException {
             Field f = obj.getClass().getField(name);
             Object out = f.get(obj);
             return out;
         }

         public static Object getDeclaredField(Object obj, String name) throws SecurityException, NoSuchFieldException,IllegalArgumentException, IllegalAccessException {
             Field f = obj.getClass().getDeclaredField(name);
             f.setAccessible(true);
             Object out = f.get(obj);
             return out;
         }

 //      public void editStaticWifiConfig(final ScanResult sr,String pwd, String ip, String gateway,int prefixLength,String dns) throws Exception{
 //          WifiConfiguration historyWifiConfig = getHistoryWifiConfig(sr.SSID);
 //
 //          if(historyWifiConfig == null){
 //              historyWifiConfig = createComWifiConfig(sr.SSID,pwd);
 //              int netId = mWifiManager.addNetwork(historyWifiConfig);
 //              mWifiManager.enableNetwork(netId, true);
 //          }
 //
 //          setIpAssignment("STATIC", historyWifiConfig); //"STATIC" or "DHCP" for dynamic setting
 //          setIpAddress(InetAddress.getByName(ip), prefixLength, historyWifiConfig);
 //          setGateway(InetAddress.getByName(gateway), historyWifiConfig);
 //          setDNS(InetAddress.getByName(dns), historyWifiConfig);
 //
 //          mWifiManager.updateNetwork(historyWifiConfig); //apply the setting
 //      }
 //
 //      public void editDhcpWifiConfig(final ScanResult sr,String pwd) throws Exception{
 //          WifiConfiguration historyWifiConfig = getHistoryWifiConfig(sr.SSID);
 //
 //          if(historyWifiConfig == null){
 //              historyWifiConfig = createComWifiConfig(sr.SSID,pwd);
 //              int netId = mWifiManager.addNetwork(historyWifiConfig);
 //              mWifiManager.enableNetwork(netId, true);
 //          }
 //
 //          setIpAssignment("DHCP", historyWifiConfig); //"STATIC" or "DHCP" for dynamic setting
 //
 //          mWifiManager.updateNetwork(historyWifiConfig); //apply the setting
 //      }
 }

类中注释高级选项处，是连接上wifi同时自己设定ip.记得wifiManager.updateNetwork(wifiConfig);

类中boolean bRet = wifiManager.enableNetwork(netID, true); 第二个参数true表示如果当前已经有连上一个wifi,要强制连到自己设定的wifi上，此参数必须为true否则连上的还是原来的wifi.

调用此类示例

 WifiManager wifiManager = (WifiManager) getSystemService(Context.WIFI_SERVICE);
 WifiConnect wifi = new WifiConnect(wifiManager);
 wifi.Connect("wifiName", "wifipPassword",
         WifiCipherType.WIFICIPHER_WPA);

需要的权限

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


 <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
 <uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
 <uses-permission android:name="android.permission.UPDATE_DEVICE_STATS" />
 <uses-permission android:name="android.permission.WAKE_LOCK" />

如何在广播监听wifi的状态

广播接收类

 package rodar.rgs.conference.utils;

 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.net.NetworkInfo;
 import android.net.wifi.WifiInfo;
 import android.net.wifi.WifiManager;
 import android.os.Bundle;
 import android.os.Parcelable;
 import android.util.Log;

 public class WifiStateReceiver extends BroadcastReceiver{

 //  0 --> WIFI_STATE_DISABLING
 //  1 --> WIFI_STATE_DISABLED
 //  2 --> WIFI_STATE_ENABLING
 //  3 --> WIFI_STATE_ENABLED
 //  4 --> WIFI_STATE_UNKNOWN


     @Override
     public void onReceive(Context context, Intent intent) {
         // TODO Auto-generated method stub
         Bundle bundle = intent.getExtras();
           int oldInt = bundle.getInt("previous_wifi_state");
           int newInt = bundle.getInt("wifi_state");

           System.out.println(">>>oldInt="+oldInt+",newInt="+newInt);
 //        String oldStr = (oldInt>=0 && oldInt<WIFI_STATES.length) ?WIFI_STATES[oldInt] :"?";
 //        String newStr = (newInt>=0 && oldInt<WIFI_STATES.length) ?WIFI_STATES[newInt] :"?";
 //        Log.e("", "oldS="+oldStr+", newS="+newStr);
 //        if(newInt==WifiManager.WIFI_STATE_DISABLED || newInt==WifiManager.WIFI_STATE_ENABLED) {
 //           onWifiStateChange();  // define this function elsewhere!
 //        } else if(newInt==WifiManager.WIFI_STATE_DISABLING ||
 //                  newInt==WifiManager.WIFI_STATE_ENABLING)
 //        {
 ////           chkbox_wifi.setText(newStr);
 //        } else {
 //         newStr += " (Is wpa_supplicant.conf readable?)";
 ////           chkbox_wifi.setText(newStr);
 //        }

         WifiManager wifiManager = (WifiManager)context.getSystemService(Context.WIFI_SERVICE);
         WifiInfo info = wifiManager.getConnectionInfo();
         System.out.println(">>>onReceive.wifiInfo="+info.toString());
         System.out.println(">>>onReceive.SSID="+info.getSSID());

 //      if(!info.getSSID().equals("Rodar")){
 //          WifiConnect wifi = new WifiConnect(wifiManager);
 //          wifi.Connect("Rodar", "rodar.5779858",
 //                  WifiCipherType.WIFICIPHER_WPA);
 //          System.out.println(">>>onReceive.SSID1="+info.getSSID());
 //      }


          if (WifiManager.NETWORK_STATE_CHANGED_ACTION.equals(intent.getAction()))
          {
              Parcelable parcelableExtra = intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);
              if (null != parcelableExtra)
              {
                  NetworkInfo networkInfo = (NetworkInfo) parcelableExtra;
                  switch (networkInfo.getState())
                  {
                  case CONNECTED:
                      Log.e("APActivity", "CONNECTED");
                      break;
                  case CONNECTING:
                      Log.e("APActivity", "CONNECTING");
                      break;
                  case DISCONNECTED:
                      Log.e("APActivity", "DISCONNECTED");
                      break;
                  case DISCONNECTING:
                      Log.e("APActivity", "DISCONNECTING");
                      break;
                  case SUSPENDED:
                      Log.e("APActivity", "SUSPENDED");
                      break;
                  case UNKNOWN:
                      Log.e("APActivity", "UNKNOWN");
                      break;
                  default:
                      break;
                  }
              }
          }


     }



 //  // 显示Wifi状态以及ip地址:
 //  public static String StringizeIp(int ip) {
 //    int ip4 = (ip>>24) & 0x000000FF;
 //    int ip3 = (ip>>16) & 0x000000FF;
 //    int ip2 = (ip>> 8 )& 0x000000FF;
 //    int ip1 = ip       & 0x000000FF;
 //    return Integer.toString(ip1) + "." + ip2 + "." + ip3 + "." + ip4;
 //  }
 //  private void onWifiStateChange() {
 //           String ip_str = "";
 //           WifiInfo info = mMainWifi.getConnectionInfo();
 //           if(info != null) {
 //            int ipaddr = info.getIpAddress();
 //            ip_str = " (ip="+StringizeIp(ipaddr)+")";
 //           }
 //
 //          if(mMainWifi.isWifiEnabled()==true)
 //                 chkbox_wifi.setText("Wifi is on [" + ip_str + "]");
 //          else
 //                 chkbox_wifi.setText("Wifi is off");
 //
 //  }
 }

注册和取消广播一般在onstart和onstop里

 WifiStateReceiver wifiStateReceiver;
 @Override
 protected void onStart() {
     //注册网络监听
     wifiStateReceiver = new WifiStateReceiver();
     IntentFilter filter = new IntentFilter();
     filter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
     filter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
     registerReceiver(wifiStateReceiver, filter);

     super.onStart();
 }

 @Override
 protected void onStop() {
     //注销网络监听
     unregisterReceiver(wifiStateReceiver);
     super.onStop();
 }