获取系统Wifi的工具类

　智能家居这个词，相信大家并不陌生智能家居（英文：smart home, home automation）是以住宅为平台，利用综合布线技术、网络通信技术、 安全防范技术、自动控制技术、音视频技术将家居生活有关的设施集成，构建高效的住宅设施与家庭日程事务的管理系统，提升家居安全性、便利性、舒适性、艺术性，并实现环保节能的居住环境。

【两种方式】

　　实现智能控制的方法，我了解到的有两种：

• 一种是通过wifi或者2G、3G、4G网络将手机和智能设备连接起来，实现打开，关闭，设定等操作。

• 一种是通过蓝牙将手机和智能设备连接起来，实现设备的打开、关闭等操作。

• public class WifiUtil {
      // 定义WifiManager对象
      private WifiManager mWifiManager;
      // 定义WifiInfo对象
      private WifiInfo mWifiInfo;
      // 扫描出的网络连接列表
      private List<ScanResult> mWifiList;
      // 网络连接列表
      private List<WifiConfiguration> mWifiConfiguration;
      // 定义一个WifiLock
      WifiManager.WifiLock mWifiLock;
  
      // 构造器
      public WifiUtil(Context context) {
          // 取得WifiManager对象
          mWifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
          // 取得WifiInfo对象
          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();
      }
  
      // 锁定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();
      }
  
      // 得到网络列表
      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();
      }
  
      // 得到IP地址
      public int getIPAddress() {
          return (mWifiInfo == null) ? 0 : mWifiInfo.getIpAddress();
      }
  
      // 得到连接的ID
      public int getNetworkId() {
          return (mWifiInfo == null) ? 0 : mWifiInfo.getNetworkId();
      }
  
      // 得到WifiInfo的所有信息包
      public WifiInfo getWifiInfo() {
          return this.mWifiManager.getConnectionInfo();
      }
  
      // 添加一个网络并连接
      public void addNetwork(WifiConfiguration wcg) {
          int wcgID = mWifiManager.addNetwork(wcg);
          boolean b = mWifiManager.enableNetwork(wcgID, true);
          if (b) {
              ToastUtil.showToast("连接成功");
          } else {
              ToastUtil.showToast("连接失败");
          }
      }
  
      // 断开指定ID的网络
      public void disconnectWifi(int netId) {
          mWifiManager.disableNetwork(netId);
          mWifiManager.disconnect();
      }
  
      //根据ssid判断该wifi是否连接
      public boolean isCurrentConnect(String ssID) {
          ssID = "\"" + ssID + "\"";
          WifiInfo info = getWifiInfo();
          //当前的ssid为空，未连接wifi
          if (TextUtils.isEmpty(info.getSSID())) {
              return false;
          } else {
              String tempSSID = info.getSSID();
              if (tempSSID.equals(ssID)) {
                  return true;
              } else {
                  return false;
              }
          }
      }
  
      //去除重复同名信号
      public List<ScanResult> rmWeakSameNameScanResult(List<ScanResult> list) {
          for (int i = 0; i < list.size() - 1; i++) {
              for (int j = list.size() - 1; j > i; j--) {
                  ScanResult scanResultTmpI = list.get(i);
                  ScanResult scanResultTmpJ = list.get(j);
                  if (scanResultTmpJ.SSID.equals(scanResultTmpI.SSID)) {
                      list.remove(j);
                  }
              }
          }
          return list;
      }
  
      //去除空字符串
      public List<ScanResult> rmScanResult(List<ScanResult> list) {
          for (int i = 0; i < list.size() - 1; i++) {
              for (int j = list.size() - 1; j > i; j--) {
                  ScanResult scanResultTmpI = list.get(i);
                  ScanResult scanResultTmpJ = list.get(j);
                  if (scanResultTmpJ.SSID.equals("")) {
                      list.remove(j);
                  }
              }
          }
          return list;
      }
  
      //按照信号强弱排序
      public List<ScanResult> BubbleSort(List<ScanResult> list) {
          if (list != null && list.size() > 0) {
              ScanResult scanResultTmpPre = null;
              ScanResult scanResultTmpNex = null;
              for (int i = 0; i < list.size() - 1; i++) {
                  for (int j = 0; j < list.size() - i - 1; j++) {
                      scanResultTmpPre = list.get(j);
                      scanResultTmpNex = list.get(j + 1);
                      //升序，信号是负值
                      if (Math.abs(scanResultTmpPre.level) > Math.abs(scanResultTmpNex.level)) {
                          list.set(j, scanResultTmpNex);
                          list.set(j + 1, scanResultTmpPre);
                          scanResultTmpPre = null;
                          scanResultTmpNex = null;
                      }
                  }
              }
          }
          //将当前已连接的wifi放在第一位
          List<ScanResult> scanResults = new ArrayList<>();
          for (ScanResult scanResult : list) {
              if (scanResult.SSID.equals(getWifiInfo().getSSID())) {
                  scanResults.add(scanResult);
              }
          }
          for (ScanResult scanResult : list) {
              if (!scanResult.SSID.equals(getWifiInfo().getSSID())) {
                  scanResults.add(scanResult);
              }
          }
  
          return scanResults;
      }
  
      /**
       * 判断 ssid 连接过、
       *
       * @param SSID
       * @return
       */
      public int IsConfiguration(String SSID) {
          List<WifiConfiguration> wifiConfigList = getConfiguration();
          for (int i = 0; i < wifiConfigList.size(); i++) {
              if (wifiConfigList.size() > 0) {
                  if (SSID.equals(wifiConfigList.get(i).SSID)) {//地址相同
                      return wifiConfigList.get(i).networkId;
                  }
              }
          }
          return -1;
      }
  
      //只验证过没有密码的情况：
      public WifiConfiguration CreateWifiInfo(String 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 = "\"" + SSID + "\"";
  
          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;
      }
  
  }