devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android wifiManager的使用案例

作者：笔触狂放9 | 2024-03-23 13:44:57

赞

踩

android wifimanager

在平常开发中经常会涉及到wifi相关的内容，在此将之前所用到的整理一下，以免忘记。

操作wifi的相关类，主要放在android.net.wifi包下面。使用wifi相关方法需要申请一些权限：

 

ACCESS_WIFI_STATE 获取WiFi状态。

CHANGE_WIFI_STATE     改变WiFi状态。

CHANGE_WIFI_MULTICAST_STATE 改变WiFi多播状态

申请权限方式：在AndroidManifest.xml文件中填写

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

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


wifi相关操作所需要用到的类。


先说一下wifi的基本使用情况。

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

        

俩bug

这些代码看起来没有什么问题，但是通过不同环境的测试，发现了一些问题。

1  测试到的wifi热点，有的ssid为”“，也就是ssid ！＝ null,获取不到said。

2  wifi列表中有许多同名的wifi热点，也就是扫描的结果中有重合部分，并不是有多个同名的wifi热点。

第一个问题ssid为“”，这个看设置中并没有多余wifi，但这个热点点其它信息可以获取到，说明这个热点是存在的，应该是该热点隐藏了，所以获取不到。这也就是手机设置中为什么会有添加网路的按钮了。

第二个问题，当附近wifi热点比较少时不会出现此问题，当附近wifi网络比较多时会出现此问题。这就需要将同名的热点进行删除，但是如果真有两个ssid名相同的wifi，那就可以通过capabilities去区分吧，如果capabilities也相同就没办法了，系统设置里面也不显示同名的。

修改上面的方法 startScan（）。

[java]  view plain  copy
 print ?
  1. public void startScan(Context context) {    
  2.     mWifiManager.startScan();  
  3.        //得到扫描结果   
  4.     List<ScanResult> results = mWifiManager.getScanResults();   
  5.     // 得到配置好的网络连接   
  6.     mWifiConfiguration = mWifiManager.getConfiguredNetworks();   
  7.     if (results == null) {  
  8.         if(mWifiManager.getWifiState()==3){  
  9.             Toast.makeText(context,"当前区域没有无线网络",Toast.LENGTH_SHORT).show();  
  10.         }else if(mWifiManager.getWifiState()==2){  
  11.             Toast.makeText(context,"wifi正在开启，请稍后扫描", Toast.LENGTH_SHORT).show();  
  12.         }else{Toast.makeText(context,"WiFi没有开启", Toast.LENGTH_SHORT).show();  
  13.         }  
  14.     } else {  
  15.     mWifiList = new ArrayList();  
  16.     for(ScanResult result : results){   
  17.         if (result.SSID == null || result.SSID.length() == 0 || result.capabilities.contains("[IBSS]")) {  
  18.             continue;  
  19.         }  
  20.         boolean found = false;  
  21.         for(ScanResult item:mWifiList){   
  22.                     if(item.SSID.equals(result.SSID)&&item.capabilities.equals(result.capabilities)){  
  23.                 found = true;break;   
  24.             }  
  25.         }   
  26.         if(!found){  
  27.             mWifiList.add(result);  
  28.         }   
  29.     }   
  30.     }   
  31. }  
这样就可以避免出现上面的两种情况了。 
 

         
 

 代码 
 

 
 

 
 
 
  
 
   [java]  
   view plain 
    copy 
   
 
   
 
    print 
   ? 
  
 
 
 
 
  1.  public class MainActivity extends Activity implements OnClickListener {  
  2.      public static final String TAG = "MainActivity";  
  3.      private Button check_wifi,open_wifi,close_wifi,scan_wifi;  
  4.      private ListView mlistView;  
  5.      protected WifiAdmin mWifiAdmin;  
  6.      private List<ScanResult> mWifiList;  
  7.      public int level;  
  8.      protected String ssid;  
  9.        
  10.      protected void onCreate(Bundle savedInstanceState) {  
  11.          super.onCreate(savedInstanceState);  
  12.          setContentView(R.layout.activity_main);  
  13.          mWifiAdmin = new WifiAdmin(MainActivity.this);  
  14.          initViews();  
  15.          IntentFilter filter = new IntentFilter(  
  16.                  WifiManager.NETWORK_STATE_CHANGED_ACTION);  
  17.          //="android.net.wifi.STATE_CHANGE"  监听wifi状态的变化  
  18.          registerReceiver(mReceiver, filter);  
  19.          mlistView.setOnItemClickListener(new OnItemClickListener() {  
  20.              @Override  
  21.              public void onItemClick(AdapterView<?> parent, View view,  
  22.                      int position, long id) {  
  23.                  AlertDialog.Builder alert=new AlertDialog.Builder(MainActivity.this);  
  24.                  ssid=mWifiList.get(position).SSID;  
  25.                  alert.setTitle(ssid);  
  26.                  alert.setMessage("输入密码");  
  27.                  final EditText et_password=new EditText(MainActivity.this);  
  28.                  final SharedPreferences preferences=getSharedPreferences("wifi_password",Context.MODE_PRIVATE);  
  29.                  et_password.setText(preferences.getString(ssid, ""));  
  30.                  alert.setView(et_password);  
  31.                  //alert.setView(view1);  
  32.                  alert.setPositiveButton("连接", new DialogInterface.OnClickListener(){  
  33.                      @Override  
  34.                      public void onClick(DialogInterface dialog, int which) {  
  35.                          String pw = et_password.getText().toString();  
  36.                          if(null == pw  || pw.length() < 8){  
  37.                                      Toast.makeText(MainActivity.this, "密码至少8位", Toast.LENGTH_SHORT).show();  
  38.                                  return;      
  39.                              }  
  40.                              Editor editor=preferences.edit();  
  41.                              editor.putString(ssid, pw);   //保存密码  
  42.                              editor.commit();          
  43.                          mWifiAdmin.addNetwork(mWifiAdmin.CreateWifiInfo(ssid, et_password.getText().toString(), 3));  
  44.                      }  
  45.                  });  
  46.                  alert.setNegativeButton("取消", new DialogInterface.OnClickListener(){  
  47.                      @Override  
  48.                      public void onClick(DialogInterface dialog, int which) {  
  49.                          //  
  50.                          //mWifiAdmin.removeWifi(mWifiAdmin.getNetworkId());  
  51.                      }  
  52.                  });  
  53.                  alert.create();  
  54.                  alert.show();  
  55.                    
  56.              }  
  57.          });  
  58.      }  
  59.        
  60.      /* 
  61.       * 控件初始化 
  62.       * */  
  63.      private void initViews() {  
  64.          check_wifi=(Button) findViewById(R.id.check_wifi);  
  65.          open_wifi=(Button) findViewById(R.id.open_wifi);  
  66.          close_wifi=(Button) findViewById(R.id.close_wifi);  
  67.          scan_wifi=(Button) findViewById(R.id.scan_wifi);  
  68.          mlistView=(ListView) findViewById(R.id.wifi_list);                
  69.          check_wifi.setOnClickListener(MainActivity.this);  
  70.          open_wifi.setOnClickListener(MainActivity.this);  
  71.          close_wifi.setOnClickListener(MainActivity.this);  
  72.          scan_wifi.setOnClickListener(MainActivity.this);  
  73.      }  
  74.    
  75.      @Override  
  76.      public void onClick(View v) {  
  77.          switch (v.getId()) {  
  78.          case R.id.check_wifi:  
  79.              mWifiAdmin.checkState(MainActivity.this);  
  80.              break;  
  81.          case R.id.open_wifi:  
  82.              mWifiAdmin.openWifi(MainActivity.this);  
  83.              break;  
  84.          case R.id.close_wifi:  
  85.              mWifiAdmin.closeWifi(MainActivity.this);  
  86.              break;  
  87.          case R.id.scan_wifi:  
  88.              mWifiAdmin.startScan(MainActivity.this);  
  89.              mWifiList=mWifiAdmin.getWifiList();  
  90.              if(mWifiList!=null){  
  91.                  mlistView.setAdapter(new MyAdapter(this,mWifiList));  
  92.                  new Utility().setListViewHeightBasedOnChildren(mlistView);  
  93.              }  
  94.              break;  
  95.          default:  
  96.              break;  
  97.          }  
  98.      }  
  99.        
  100.      public class MyAdapter extends BaseAdapter{  
  101.          LayoutInflater inflater;  
  102.          List<ScanResult> list;  
  103.          public MyAdapter(Context context, List<ScanResult> list){  
  104.              this.inflater=LayoutInflater.from(context);  
  105.              this.list=list;  
  106.          }  
  107.          @Override  
  108.          public int getCount() {  
  109.              return list.size();  
  110.          }  
  111.          @Override  
  112.          public Object getItem(int position) {  
  113.              return position;  
  114.          }  
  115.          @Override  
  116.          public long getItemId(int position) {  
  117.              return position;  
  118.          }  
  119.          @SuppressLint({ "ViewHolder", "InflateParams" })  
  120.          @Override  
  121.          public View getView(int position, View convertView, ViewGroup parent) {  
  122.              View view=null;  
  123.              view=inflater.inflate(R.layout.wifi_listitem, null);  
  124.              ScanResult scanResult = list.get(position);  
  125.              TextView wifi_ssid=(TextView) view.findViewById(R.id.ssid);  
  126.              ImageView wifi_level=(ImageView) view.findViewById(R.id.wifi_level);  
  127.              wifi_ssid.setText(scanResult.SSID);  
  128.              Log.i(TAG, "scanResult.SSID="+scanResult);  
  129.              level=WifiManager.calculateSignalLevel(scanResult.level,5);  
  130.              if(scanResult.capabilities.contains("WEP")||scanResult.capabilities.contains("PSK")||  
  131.                      scanResult.capabilities.contains("EAP")){  
  132.                  wifi_level.setImageResource(R.drawable.wifi_signal_lock);  
  133.              }else{  
  134.                  wifi_level.setImageResource(R.drawable.wifi_signal_open);  
  135.              }  
  136.              wifi_level.setImageLevel(level);  
  137.              //判断信号强度，显示对应的指示图标    
  138.               return view;  
  139.          }  
  140.      }  
  141.    
  142.      /*设置listview的高度*/  
  143.      public class Utility {   
  144.          public void setListViewHeightBasedOnChildren(ListView listView) {   
  145.              ListAdapter listAdapter = listView.getAdapter();    
  146.              if (listAdapter == null) {   
  147.                  return;   
  148.              }   
  149.              int totalHeight = 0;   
  150.              for (int i = 0; i < listAdapter.getCount(); i++) {   
  151.                  View listItem = listAdapter.getView(i, null, listView);   
  152.                  listItem.measure(0, 0);   
  153.                  totalHeight += listItem.getMeasuredHeight();   
  154.              }   
  155.              ViewGroup.LayoutParams params = listView.getLayoutParams();   
  156.              params.height = totalHeight + (listView.getDividerHeight() * (listAdapter.getCount() - 1));   
  157.              listView.setLayoutParams(params);   
  158.          }   
  159.      }  
  160.      //监听wifi状态  
  161.      private BroadcastReceiver mReceiver = new BroadcastReceiver (){    
  162.          @Override    
  163.          public void onReceive(Context context, Intent intent) {     
  164.              ConnectivityManager manager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);    
  165.    
  166.              NetworkInfo wifiInfo = manager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);     
  167.              if(wifiInfo.isConnected()){  
  168.                  WifiManager wifiManager = (WifiManager) context  
  169.                          .getSystemService(Context.WIFI_SERVICE);  
  170.                  String wifiSSID = wifiManager.getConnectionInfo()  
  171.                          .getSSID();  
  172.                  Toast.makeText(context, wifiSSID+"连接成功", 1).show();  
  173.              }                  
  174.          }     
  175.          
  176.      };   
  177.  }  
 

 

 

 ScanResult类
 
 

 

 这个类主要是通过Wifi硬件的扫描来获取一些周边的wifi热点（access point）的信息。该类主要有5个域，
 

 
 

返回类型域名解释
public StringBSSID接入点的地址
public StringSSID网络的名字
public Stringcapabilities网络性能，包括接入点支持的认证、密钥管理、加密机制等
public intfrequency以MHz为单位的接入频率
public intlevel以dBm为单位的信号强度。
 

 

 
 

 打印信息如下所示：
 

 
 

 
 
 

 WifiConfiguration类
 

 通过该类获取一个wifi网络的网络配置，包括安全配置等。它包含6个子类，如下所示：
 

 
 

子类解释
WifiConfiguration.AuthAlgorthm获取IEEE 802.11的加密方法
WifiConfiguration.GroupCipher
 		获取组密钥
WifiConfiguration.KeyMgmt
 		获取密码管理体制
WifiConfiguration.PairwiseCipher
 		获取WPA方式的成对密钥
WifiConfiguration.Protocol
 		获取加密协议
WifiConfiguration.Status
 		获取当前网络状态
 
该类内容较多，不一一例举，需要用到的时候可以查Android SDK。 

 
 

 WifiInfo类
 

 
 
 

 该类可以获得已经建立的或处于活动状态的wifi网络的状态信息。常用方法如下：
 

 
 
 

 
 
 

 
 
 

 
 
 

 代码：
 

 
 

 
 
 
  
 
   [java]  
   view plain 
    copy 
   
 
   
 
    print 
   ? 
  
 
 
 
 
  1.  mWifiManager = (WifiManager)getSystemService(Context.WIFI_SERVICE);     
  2.  mWifiInfo = mWifiManager.getConnectionInfo();  
  3.  if(null != mWifiInfo && null != mWifiInfo.getSSID()){  
  4.          String info = "getSSID()="+mWifiInfo.getSSID()+"\n"  
  5.                  +"getBSSID()="+mWifiInfo.getBSSID()+"\n"  
  6.                  +"getHiddenSSID()="+mWifiInfo.getHiddenSSID()+"\n"  
  7.                  +"getLinkSpeed()="+mWifiInfo.getLinkSpeed()+"\n"  
  8.                  +"getMacAddress()="+mWifiInfo.getMacAddress()+"\n"  
  9.                  +"getNetworkId()="+mWifiInfo.getNetworkId()+"\n"  
  10.                  +"getRssi()="+mWifiInfo.getRssi()+"\n"  
  11.                  +"getSupplicantState()="+mWifiInfo.getSupplicantState()+"\n"  
  12.                  +"getDetailedStateOf()="+mWifiInfo.getDetailedStateOf(mWifiInfo.getSupplicantState());  
  13.          mTVWifiInfo.setText(info);  
  14.  }else {  
  15.          mTVWifiInfo.setText("没有连接到wifi");  
  16.  }  
 

 

 WifiManager类
 

 该类用于管理Wifi连接，定义了许多常量和方法，这里就不一一说了。
 

 常用方法。
 

 
 
 

 
 
 

 需要指出的是getWifiState()方法是反悔wifi的状态，有整型常量表示，
 

 
 
 

 
 
  


                

        
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/295544
推荐阅读
相关标签
Copyright ©  2003-2013 www.wpsshop.cn  版权所有，并保留所有权利。

  
闽ICP备14008679号