Android之Wifi学习教程

在Android中对Wifi操作，android本身提供了一些有用的包，在android.net.wifi包下面。简单介绍一下：

大致可以分为四个主要的类ScanResult,wifiConfiguration,WifiInfo,WifiManager

(1)ScanResult，主要是通过wifi 硬件的扫描来获取一些周边的wifi 热点的信息。

(2)wifiConfiguration 在我们连通一个wifi 接入点的时候，需要获取到的一些信息。大家可以跟我们有线的设备进行对比一下。

(3)WifiInfo 在我们的wifi 已经连通了以后，可以通过这个类获得一些已经连通的wifi 连接的信息获取当前链接的信息，这里信息就比较简单了，这里简单介绍一下这里的方法:

       getBSSID() 获取BSSID

       getDetailedStateOf() 获取客户端的连通性

       getHiddenSSID() 获得SSID 是否被隐藏

       getIpAddress() 获取IP 地址

       getLinkSpeed() 获得连接的速度

       getMacAddress() 获得Mac 地址

       getRssi() 获得802.11n 网络的信号

       getSSID() 获得SSID

       getSupplicanState() 返回具体客户端状态的信息

(4)wifiManager 这个不用说，就是用来管理我们的wifi 连接，这里已经定义好了一些类，可以供我们使用。这里来说相对复杂，里面的内容比较多，但是通过字面意思，我们还是可以获得很多相关的信息。这个类里面预先定义了许多常量，我们可以直接使用，不用再次创建。

介绍完了，开始写一个Demo吧。程序已启动效果图如下：

看代码，其中有注释，我就不多说了。

布局文件代码：

1. <scrollview xmlns:android="http://schemas.android.com/apk/res/android" 
   
2.     android:id="@+id/mScrollView" android:layout_width="fill_parent"  
   
3.     android:layout_height="wrap_content" android:scrollbars="vertical">
   
4. <linearlayout xmlns:android="http://schemas.android.com/apk/res/android" 
   
5.     android:orientation="vertical"
   
6.     android:layout_width="fill_parent"
   
7.     android:layout_height="fill_parent"
   
8.     >
   
9. <textview
   
10.     android:id="@+id/allNetWork"
    
11.     android:layout_width="fill_parent"
    
12.     android:layout_height="wrap_content" 
    
13.     android:text="当前没有扫描到Wifi网络"
    
14.     />
    
15. <button
    
16.     android:id="@+id/scan"
    
17.     android:layout_width="wrap_content" 
    
18.     android:layout_height="wrap_content" 
    
19.     android:text="扫描网络"
    
20.     />
    
21. <button
    
22.     android:id="@+id/start"
    
23.     android:layout_width="wrap_content" 
    
24.     android:layout_height="wrap_content" 
    
25.     android:text="打开Wifi"
    
26.     />
    
27. <button
    
28.     android:id="@+id/stop"
    
29.     android:layout_width="wrap_content" 
    
30.     android:layout_height="wrap_content" 
    
31.     android:text="关闭Wifi"
    
32.     />
    
33. <button
    
34.     android:id="@+id/check"
    
35.     android:layout_width="wrap_content" 
    
36.     android:layout_height="wrap_content" 
    
37.     android:text="Wifi状态"
    
38.     />
    
39. </button
    
40. </button
    
41. </button
    
42. </button
    
43. </textview

复制代码

上面布局文件中的ScrollView用来在Activity中显示右侧滚动条，如果数据多的话，则可以往下滑动继续显示未显示完的数据。主页面代码：

1. package org.sunchao;
   
2. 
   
3. import java.util.List;
   
4. 
   
5. import android.app.Activity;
   
6. import android.net.wifi.ScanResult;
   
7. import android.os.Bundle;
   
8. import android.view.View;
   
9. import android.view.View.OnClickListener;
   
10. import android.widget.Button;
    
11. import android.widget.ScrollView;
    
12. import android.widget.TextView;
    
13. import android.widget.Toast;
    
14. 
    
15. public class Main extends Activity implements OnClickListener {
    
16.         // 右侧滚动条按钮
    
17.         private ScrollView sView; 
    
18.         private TextView allNetWork;
    
19.         private Button scan;
    
20.         private Button start;
    
21.         private Button stop;
    
22.         private Button check;
    
23.         private WifiAdmin mWifiAdmin;
    
24.         // 扫描结果列表
    
25.         private List list;
    
26.         private ScanResult mScanResult;
    
27.         private StringBuffer mStringBuffer = new StringBuffer();
    
28. 
    
29.         /** Called when the activity is first created. */
    
30.         @Override
    
31.         public void onCreate(Bundle savedInstanceState) {
    
32.                 super.onCreate(savedInstanceState);
    
33.                 setContentView(R.layout.main);
    
34.                 mWifiAdmin = new WifiAdmin(Main.this);
    
35.                 init();
    
36.         }
    
37. 
    
38.         // 按钮的初始化
    
39.         public void init() {
    
40.                 sView = (ScrollView) findViewById(R.id.mScrollView);
    
41.                 allNetWork = (TextView) findViewById(R.id.allNetWork);
    
42.                 scan = (Button) findViewById(R.id.scan);
    
43.                 start = (Button) findViewById(R.id.start);
    
44.                 stop = (Button) findViewById(R.id.stop);
    
45.                 check = (Button) findViewById(R.id.check);
    
46.                 scan.setOnClickListener(Main.this);
    
47.                 start.setOnClickListener(Main.this);
    
48.                 stop.setOnClickListener(Main.this);
    
49.                 check.setOnClickListener(Main.this);
    
50.         }
    
51. 
    
52.         // WIFI_STATE_DISABLING 0
    
53.         // WIFI_STATE_DISABLED 1
    
54.         // WIFI_STATE_ENABLING 2
    
55.         // WIFI_STATE_ENABLED 3
    
56.         public void start() {
    
57.                 mWifiAdmin.openWifi();
    
58.                 Toast.makeText(Main.this, "当前Wifi网卡状态为" + mWifiAdmin.checkState(),
    
59.                                 Toast.LENGTH_SHORT).show();
    
60.         }
    
61. 
    
62.         public void stop() {
    
63.                 mWifiAdmin.closeWifi();
    
64.                 Toast.makeText(Main.this, "当前Wifi网卡状态为" + mWifiAdmin.checkState(),
    
65.                                 Toast.LENGTH_SHORT).show();
    
66.         }
    
67. 
    
68.         public void check() {
    
69.                 Toast.makeText(Main.this, "当前Wifi网卡状态为" + mWifiAdmin.checkState(),
    
70.                                 Toast.LENGTH_SHORT).show();
    
71.         }
    
72. 
    
73.         public void getAllNetWorkList() {
    
74.                 // 每次点击扫描之前清空上一次的扫描结果
    
75.                 if (mStringBuffer != null) {
    
76.                         mStringBuffer = new StringBuffer();
    
77.                 }
    
78. 
    
79.                 // 开始扫描网络
    
80.                 mWifiAdmin.startScan();
    
81.                 list = mWifiAdmin.getWifiList();
    
82. 
    
83.                 if (list != null) {
    
84.                         for (int i = 0; i < list.size(); i++) {
    
85.                                 mScanResult = list.get(i);
    
86.                                 // 得到网络的SSID：the network name
    
87.                                 mStringBuffer = mStringBuffer
    
88.                                         .append(mScanResult.SSID).append("        ")
    
89.                                         .append(mScanResult.BSSID).append("        ")
    
90.                                         .append(mScanResult.capabilities).append("        ")
    
91.                                         .append(mScanResult.frequency).append("        ")
    
92.                                         .append(mScanResult.level).append("        ")
    
93.                                         .append("");
    
94.                         }
    
95.                         allNetWork.setText("扫描到的所有Wifi网络：" + mStringBuffer.toString());
    
96.                 }
    
97.         }
    
98. 
    
99.         @Override
    
100.         public void onClick(View v) {
     
101.                 switch (v.getId()) {
     
102.                 case R.id.scan:
     
103.                         getAllNetWorkList();
     
104.                         break;
     
105.                 case R.id.start:
     
106.                         start();
     
107.                         break;
     
108.                 case R.id.stop:
     
109.                         stop();
     
110.                         break;
     
111.                 case R.id.check:
     
112.                         check();
     
113.                         break;
     
114.                 default:
     
115.                         break;
     
116.                 }
     
117.         }
     
118. }

复制代码

上面用到了一个WifiAdmin类，这是我自己写的一个类，用于对Wifi的操作进行一次封装，里面的方法很多，我们本次Demo只用到了其中几种，但我还是先全部放上去吧，以后会用到的。WifiAdmin工具类代码：

1. package org.sunchao;
   
2. 
   
3. import java.util.List;
   
4. 
   
5. import android.content.Context;
   
6. import android.net.wifi.ScanResult;
   
7. import android.net.wifi.WifiConfiguration;
   
8. import android.net.wifi.WifiInfo;
   
9. import android.net.wifi.WifiManager;
   
10. import android.net.wifi.WifiManager.WifiLock;
    
11. 
    
12. public class WifiAdmin {
    
13.         // 定义WifiManager对象
    
14.         private WifiManager mWifiManager;
    
15.         // 定义WifiInfo对象
    
16.         private WifiInfo mWifiInfo;
    
17.         // 扫描出的网络连接列表
    
18.         private List mWifiList;
    
19.         // 网络连接列表
    
20.         private List mWifiConfiguration;
    
21.         // 定义一个WifiLock
    
22.         WifiLock mWifiLock;
    
23. 
    
24.         // 构造器
    
25.         public WifiAdmin(Context context) {
    
26.                 // 取得WifiManager对象
    
27.                 mWifiManager = (WifiManager) context
    
28.                                 .getSystemService(Context.WIFI_SERVICE);
    
29.                 // 取得WifiInfo对象
    
30.                 mWifiInfo = mWifiManager.getConnectionInfo();
    
31.         }
    
32. 
    
33.         // 打开WIFI
    
34.         public void openWifi() {
    
35.                 if (!mWifiManager.isWifiEnabled()) {
    
36.                         mWifiManager.setWifiEnabled(true);
    
37.                 }
    
38.         }
    
39. 
    
40.         // 关闭WIFI
    
41.         public void closeWifi() {
    
42.                 if (mWifiManager.isWifiEnabled()) {
    
43.                         mWifiManager.setWifiEnabled(false);
    
44.                 }
    
45.         }
    
46. 
    
47.         // 检查当前WIFI状态
    
48.         public int checkState() {
    
49.                 return mWifiManager.getWifiState();
    
50.         }
    
51. 
    
52.         // 锁定WifiLock
    
53.         public void acquireWifiLock() {
    
54.                 mWifiLock.acquire();
    
55.         }
    
56. 
    
57.         // 解锁WifiLock
    
58.         public void releaseWifiLock() {
    
59.                 // 判断时候锁定
    
60.                 if (mWifiLock.isHeld()) {
    
61.                         mWifiLock.acquire();
    
62.                 }
    
63.         }
    
64. 
    
65.         // 创建一个WifiLock
    
66.         public void creatWifiLock() {
    
67.                 mWifiLock = mWifiManager.createWifiLock("Test");
    
68.         }
    
69. 
    
70.         // 得到配置好的网络
    
71.         public List getConfiguration() {
    
72.                 return mWifiConfiguration;
    
73.         }
    
74. 
    
75.         // 指定配置好的网络进行连接
    
76.         public void connectConfiguration(int index) {
    
77.                 // 索引大于配置好的网络索引返回
    
78.                 if (index > mWifiConfiguration.size()) {
    
79.                         return;
    
80.                 }
    
81.                 // 连接配置好的指定ID的网络
    
82.                 mWifiManager.enableNetwork(mWifiConfiguration.get(index).networkId,
    
83.                                 true);
    
84.         }
    
85. 
    
86.         public void startScan() {
    
87.                 mWifiManager.startScan();
    
88.                 // 得到扫描结果
    
89.                 mWifiList = mWifiManager.getScanResults();
    
90.                 // 得到配置好的网络连接
    
91.                 mWifiConfiguration = mWifiManager.getConfiguredNetworks();
    
92.         }
    
93. 
    
94.         // 得到网络列表
    
95.         public List getWifiList() {
    
96.                 return mWifiList;
    
97.         }
    
98. 
    
99.         // 查看扫描结果
    
100.         public StringBuilder lookUpScan() {
     
101.                 StringBuilder stringBuilder = new StringBuilder();
     
102.                 for (int i = 0; i < mWifiList.size(); i++) {
     
103.                         stringBuilder
     
104.                                         .append("Index_" + new Integer(i + 1).toString() + ":");
     
105.                         // 将ScanResult信息转换成一个字符串包
     
106.                         // 其中把包括：BSSID、SSID、capabilities、frequency、level
     
107.                         stringBuilder.append((mWifiList.get(i)).toString());
     
108.                         stringBuilder.append("/n");
     
109.                 }
     
110.                 return stringBuilder;
     
111.         }
     
112. 
     
113.         // 得到MAC地址
     
114.         public String getMacAddress() {
     
115.                 return (mWifiInfo == null) ? "NULL" : mWifiInfo.getMacAddress();
     
116.         }
     
117. 
     
118.         // 得到接入点的BSSID
     
119.         public String getBSSID() {
     
120.                 return (mWifiInfo == null) ? "NULL" : mWifiInfo.getBSSID();
     
121.         }
     
122. 
     
123.         // 得到IP地址
     
124.         public int getIPAddress() {
     
125.                 return (mWifiInfo == null) ? 0 : mWifiInfo.getIpAddress();
     
126.         }
     
127. 
     
128.         // 得到连接的ID
     
129.         public int getNetworkId() {
     
130.                 return (mWifiInfo == null) ? 0 : mWifiInfo.getNetworkId();
     
131.         }
     
132. 
     
133.         // 得到WifiInfo的所有信息包
     
134.         public String getWifiInfo() {
     
135.                 return (mWifiInfo == null) ? "NULL" : mWifiInfo.toString();
     
136.         }
     
137. 
     
138.         // 添加一个网络并连接
     
139.         public void addNetwork(WifiConfiguration wcg) {
     
140.                 int wcgID = mWifiManager.addNetwork(wcg);
     
141.                 mWifiManager.enableNetwork(wcgID, true);
     
142.         }
     
143. 
     
144.         // 断开指定ID的网络
     
145.         public void disconnectWifi(int netId) {
     
146.                 mWifiManager.disableNetwork(netId);
     
147.                 mWifiManager.disconnect();
     
148.         }
     
149. }

复制代码

最后，我们看一下AndroidManifest.xml配置文件的代码，里面有需要用到的权限。这个比较重要，我刚开始就是忘记添加这些权限，程序一启动就挂。后来看LogCat才知道少了这些权限的。
AndroidManifest.xml：

1. <manifest xmlns:android="http://schemas.android.com/apk/res/android" 
   
2.         package="org.sunchao" android:versionCode="1" android:versionName="1.0">
   
3.         
   
4. 
   
5.         
   
6.                 
   
7.                         
   
8.                                 
   
9.                                 
   
10.                         
    
11.                 
    
12. 
    
13.         
    
14.         
    
15.         
    
16.         
    
17.         
    
18.         

复制代码

至此这个Demo就完成了，看效果图。   





```````````````````````````````````````````````

本文主要在此基础上，进一步完善程序功能，主要功能有打开无线网卡、关闭无线网卡、检查网卡状态、扫描网络、扫描结果、连接Wifi、断开Wifi、Wifi连接状态。
运行效果图如下：

 

其中连接Wifi是比较让我头疼的。需要在程序中进行连接，这会有两种情况。第一，Wifi没有密码，可以直接连接；第二，Wifi有密码，在程序中给出密码，然后连接。第一种我查阅相关资料好像确实是可以实现的，第二种我没找到，我自己也不知道该怎么去搞。最后想出一个办法，直接让程序跳到系统设置的Wifi的页面，然后让人手动去设置。观察了一下Android版的QQ，也确实是这么做的。不信你瞧：

 

点击设置网络后跳转到系统设置页面：

 

所以此处设置网络我也可以这么做，不过还是有点不爽，可能自己对Wifi这块还不是很熟悉，我会继续查阅相关API文档，到时候再跟大家分享，好了，下面贴一下源代码：
主页面：

1. package org.sunchao;
   
2. 
   
3. import android.app.Activity;
   
4. import android.content.Intent;
   
5. import android.os.Bundle;
   
6. import android.view.View;
   
7. import android.view.View.OnClickListener;
   
8. import android.widget.Button;
   
9. import android.widget.ScrollView;
   
10. import android.widget.TextView;
    
11. 
    
12. public class Main extends Activity implements OnClickListener {
    
13.         // 右侧滚动条按钮
    
14.         private ScrollView sView;
    
15.         private Button openNetCard;
    
16.         private Button closeNetCard;
    
17.         private Button checkNetCardState;
    
18.         private Button scan;
    
19.         private Button getScanResult;
    
20.         private Button connect;
    
21.         private Button disconnect;
    
22.         private Button checkNetWorkState;
    
23.         private TextView scanResult;
    
24. 
    
25.         private String mScanResult;
    
26.         private WifiAdmin mWifiAdmin;
    
27. 
    
28.         /** Called when the activity is first created. */
    
29.         @Override
    
30.         public void onCreate(Bundle savedInstanceState) {
    
31.                 super.onCreate(savedInstanceState);
    
32.                 setContentView(R.layout.main);
    
33.                 mWifiAdmin = new WifiAdmin(Main.this);
    
34.                 init();
    
35.         }
    
36. 
    
37.         /**
    
38.          * 按钮等控件的初始化
    
39.          */
    
40.         public void init() {
    
41.                 sView = (ScrollView) findViewById(R.id.mScrollView);
    
42.                 openNetCard = (Button) findViewById(R.id.openNetCard);
    
43.                 closeNetCard = (Button) findViewById(R.id.closeNetCard);
    
44.                 checkNetCardState = (Button) findViewById(R.id.checkNetCardState);
    
45.                 scan = (Button) findViewById(R.id.scan);
    
46.                 getScanResult = (Button) findViewById(R.id.getScanResult);
    
47.                 scanResult = (TextView) findViewById(R.id.scanResult);
    
48.                 connect = (Button) findViewById(R.id.connect);
    
49.                 disconnect = (Button) findViewById(R.id.disconnect);
    
50.                 checkNetWorkState = (Button) findViewById(R.id.checkNetWorkState);
    
51. 
    
52.                 openNetCard.setOnClickListener(Main.this);
    
53.                 closeNetCard.setOnClickListener(Main.this);
    
54.                 checkNetCardState.setOnClickListener(Main.this);
    
55.                 scan.setOnClickListener(Main.this);
    
56.                 getScanResult.setOnClickListener(Main.this);
    
57.                 connect.setOnClickListener(Main.this);
    
58.                 disconnect.setOnClickListener(Main.this);
    
59.                 checkNetWorkState.setOnClickListener(Main.this);
    
60.         }
    
61. 
    
62.         /**
    
63.          * WIFI_STATE_DISABLING 0 WIFI_STATE_DISABLED 1 WIFI_STATE_ENABLING 2
    
64.          * WIFI_STATE_ENABLED 3
    
65.          */
    
66.         public void openNetCard() {
    
67.                 mWifiAdmin.openNetCard();
    
68.         }
    
69. 
    
70.         public void closeNetCard() {
    
71.                 mWifiAdmin.closeNetCard();
    
72.         }
    
73. 
    
74.         public void checkNetCardState() {
    
75.                 mWifiAdmin.checkNetCardState();
    
76.         }
    
77. 
    
78.         public void scan() {
    
79.                 mWifiAdmin.scan();
    
80.         }
    
81. 
    
82.         public void getScanResult() {
    
83.                 mScanResult = mWifiAdmin.getScanResult();
    
84.                 scanResult.setText(mScanResult);
    
85.         }
    
86. 
    
87.         public void connect() {
    
88.                 mWifiAdmin.connect();
    
89. //                startActivityForResult(new Intent(
    
90. //                                android.provider.Settings.ACTION_WIFI_SETTINGS), 0);
    
91.                 startActivity(new Intent(android.provider.Settings.ACTION_WIFI_SETTINGS));
    
92.         }
    
93. 
    
94.         public void disconnect() {
    
95.                 mWifiAdmin.disconnectWifi();
    
96.         }
    
97. 
    
98.         public void checkNetWorkState() {
    
99.                 mWifiAdmin.checkNetWorkState();
    
100.         }
     
101. 
     
102.         @Override
     
103.         public void onClick(View v) {
     
104.                 switch (v.getId()) {
     
105.                 case R.id.openNetCard:
     
106.                         openNetCard();
     
107.                         break;
     
108.                 case R.id.closeNetCard:
     
109.                         closeNetCard();
     
110.                         break;
     
111.                 case R.id.checkNetCardState:
     
112.                         checkNetCardState();
     
113.                         break;
     
114.                 case R.id.scan:
     
115.                         scan();
     
116.                         break;
     
117.                 case R.id.getScanResult:
     
118.                         getScanResult();
     
119.                         break;
     
120.                 case R.id.connect:
     
121.                         connect();
     
122.                         break;
     
123.                 case R.id.disconnect:
     
124.                         disconnect();
     
125.                         break;
     
126.                 case R.id.checkNetWorkState:
     
127.                         checkNetWorkState();
     
128.                         break;
     
129.                 default:
     
130.                         break;
     
131.                 }
     
132.         }
     
133. }

复制代码

Wifi工具类：

1. package org.sunchao;
   
2. 
   
3. import java.util.List;
   
4. 
   
5. import android.content.Context;
   
6. import android.net.wifi.ScanResult;
   
7. import android.net.wifi.WifiConfiguration;
   
8. import android.net.wifi.WifiInfo;
   
9. import android.net.wifi.WifiManager;
   
10. import android.net.wifi.WifiManager.WifiLock;
    
11. import android.util.Log;
    
12. 
    
13. public class WifiAdmin {
    
14.         private final static String TAG = "WifiAdmin";
    
15.         private StringBuffer mStringBuffer = new StringBuffer();
    
16.         private List listResult;
    
17.         private ScanResult mScanResult;
    
18.         // 定义WifiManager对象
    
19.         private WifiManager mWifiManager;
    
20.         // 定义WifiInfo对象
    
21.         private WifiInfo mWifiInfo;
    
22.         // 网络连接列表
    
23.         private List mWifiConfiguration;
    
24.         // 定义一个WifiLock
    
25.         WifiLock mWifiLock;
    
26. 
    
27.         /**
    
28.          * 构造方法
    
29.          */
    
30.         public WifiAdmin(Context context) {
    
31.                 mWifiManager = (WifiManager) context
    
32.                                 .getSystemService(Context.WIFI_SERVICE);
    
33.                 mWifiInfo = mWifiManager.getConnectionInfo();
    
34.         }
    
35. 
    
36.         /**
    
37.          * 打开Wifi网卡
    
38.          */
    
39.         public void openNetCard() {
    
40.                 if (!mWifiManager.isWifiEnabled()) {
    
41.                         mWifiManager.setWifiEnabled(true);
    
42.                 }
    
43.         }
    
44. 
    
45.         /**
    
46.          * 关闭Wifi网卡
    
47.          */
    
48.         public void closeNetCard() {
    
49.                 if (mWifiManager.isWifiEnabled()) {
    
50.                         mWifiManager.setWifiEnabled(false);
    
51.                 }
    
52.         }
    
53. 
    
54.         /**
    
55.          * 检查当前Wifi网卡状态
    
56.          */
    
57.         public void checkNetCardState() {
    
58.                 if (mWifiManager.getWifiState() == 0) {
    
59.                         Log.i(TAG, "网卡正在关闭");
    
60.                 } else if (mWifiManager.getWifiState() == 1) {
    
61.                         Log.i(TAG, "网卡已经关闭");
    
62.                 } else if (mWifiManager.getWifiState() == 2) {
    
63.                         Log.i(TAG, "网卡正在打开");
    
64.                 } else if (mWifiManager.getWifiState() == 3) {
    
65.                         Log.i(TAG, "网卡已经打开");
    
66.                 } else {
    
67.                         Log.i(TAG, "---_---晕......没有获取到状态---_---");
    
68.                 }
    
69.         }
    
70. 
    
71.         /**
    
72.          * 扫描周边网络
    
73.          */
    
74.         public void scan() {
    
75.                 mWifiManager.startScan();
    
76.                 listResult = mWifiManager.getScanResults();
    
77.                 if (listResult != null) {
    
78.                         Log.i(TAG, "当前区域存在无线网络，请查看扫描结果");
    
79.                 } else {
    
80.                         Log.i(TAG, "当前区域没有无线网络");
    
81.                 }
    
82.         }
    
83. 
    
84.         /**
    
85.          * 得到扫描结果
    
86.          */
    
87.         public String getScanResult() {
    
88.                 // 每次点击扫描之前清空上一次的扫描结果
    
89.                 if (mStringBuffer != null) {
    
90.                         mStringBuffer = new StringBuffer();
    
91.                 }
    
92.                 // 开始扫描网络
    
93.                 scan();
    
94.                 listResult = mWifiManager.getScanResults();
    
95.                 if (listResult != null) {
    
96.                         for (int i = 0; i < listResult.size(); i++) {
    
97.                                 mScanResult = listResult.get(i);
    
98.                                 mStringBuffer = mStringBuffer.append("NO.").append(i + 1)
    
99.                                                 .append(" :").append(mScanResult.SSID).append("->")
    
100.                                                 .append(mScanResult.BSSID).append("->")
     
101.                                                 .append(mScanResult.capabilities).append("->")
     
102.                                                 .append(mScanResult.frequency).append("->")
     
103.                                                 .append(mScanResult.level).append("->")
     
104.                                                 .append(mScanResult.describeContents()).append("");
     
105.                         }
     
106.                 }
     
107.                 Log.i(TAG, mStringBuffer.toString());
     
108.                 return mStringBuffer.toString();
     
109.         }
     
110. 
     
111.         /**
     
112.          * 连接指定网络
     
113.          */
     
114.         public void connect() {
     
115.                 mWifiInfo = mWifiManager.getConnectionInfo();
     
116.                 
     
117.         }
     
118. 
     
119.         /**
     
120.          * 断开当前连接的网络
     
121.          */
     
122.         public void disconnectWifi() {
     
123.                 int netId = getNetworkId();
     
124.                 mWifiManager.disableNetwork(netId);
     
125.                 mWifiManager.disconnect();
     
126.                 mWifiInfo = null;
     
127.         }
     
128. 
     
129.         /**
     
130.          * 检查当前网络状态
     
131.          * 
     
132.          * @return String
     
133.          */
     
134.         public void checkNetWorkState() {
     
135.                 if (mWifiInfo != null) {
     
136.                         Log.i(TAG, "网络正常工作");
     
137.                 } else {
     
138.                         Log.i(TAG, "网络已断开");
     
139.                 }
     
140.         }
     
141. 
     
142.         /**
     
143.          * 得到连接的ID
     
144.          */
     
145.         public int getNetworkId() {
     
146.                 return (mWifiInfo == null) ? 0 : mWifiInfo.getNetworkId();
     
147.         }
     
148. 
     
149.         /**
     
150.          * 得到IP地址
     
151.          */
     
152.         public int getIPAddress() {
     
153.                 return (mWifiInfo == null) ? 0 : mWifiInfo.getIpAddress();
     
154.         }
     
155. 
     
156.         // 锁定WifiLock
     
157.         public void acquireWifiLock() {
     
158.                 mWifiLock.acquire();
     
159.         }
     
160. 
     
161.         // 解锁WifiLock
     
162.         public void releaseWifiLock() {
     
163.                 // 判断时候锁定
     
164.                 if (mWifiLock.isHeld()) {
     
165.                         mWifiLock.acquire();
     
166.                 }
     
167.         }
     
168. 
     
169.         // 创建一个WifiLock
     
170.         public void creatWifiLock() {
     
171.                 mWifiLock = mWifiManager.createWifiLock("Test");
     
172.         }
     
173. 
     
174.         // 得到配置好的网络
     
175.         public List getConfiguration() {
     
176.                 return mWifiConfiguration;
     
177.         }
     
178. 
     
179.         // 指定配置好的网络进行连接
     
180.         public void connectConfiguration(int index) {
     
181.                 // 索引大于配置好的网络索引返回
     
182.                 if (index >= mWifiConfiguration.size()) {
     
183.                         return;
     
184.                 }
     
185.                 // 连接配置好的指定ID的网络
     
186.                 mWifiManager.enableNetwork(mWifiConfiguration.get(index).networkId,
     
187.                                 true);
     
188.         }
     
189. 
     
190.         // 得到MAC地址
     
191.         public String getMacAddress() {
     
192.                 return (mWifiInfo == null) ? "NULL" : mWifiInfo.getMacAddress();
     
193.         }
     
194. 
     
195.         // 得到接入点的BSSID
     
196.         public String getBSSID() {
     
197.                 return (mWifiInfo == null) ? "NULL" : mWifiInfo.getBSSID();
     
198.         }
     
199. 
     
200.         // 得到WifiInfo的所有信息包
     
201.         public String getWifiInfo() {
     
202.                 return (mWifiInfo == null) ? "NULL" : mWifiInfo.toString();
     
203.         }
     
204. 
     
205.         // 添加一个网络并连接
     
206.         public int addNetwork(WifiConfiguration wcg) {
     
207.                 int wcgID = mWifiManager.addNetwork(mWifiConfiguration.get(3));
     
208.                 mWifiManager.enableNetwork(wcgID, true);
     
209.                 return wcgID;
     
210.         }
     
211. }

复制代码

AndroidManifest.xml:(注意需要添加的权限)

1. <?xml version="1.0" encoding="utf-8"?>
   
2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
   
3.         package="org.sunchao" android:versionCode="1" android:versionName="1.0">
   
4.         <uses-sdk android:minSdkVersion="8" />
   
5. 
   
6.         <application android:icon="@drawable/icon" android:label="@string/app_name">
   
7.                 <activity android:name=".Main" android:label="@string/app_name">
   
8.                         <intent-filter>
   
9.                                 <action android:name="android.intent.action.MAIN" />
   
10.                                 <category android:name="android.intent.category.LAUNCHER" />
    
11.                         </intent-filter>
    
12.                 </activity>
    
13. 
    
14.         </application>
    
15.         <!-- 以下是使用wifi访问网络所需的权限 -->
    
16.         <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE"></uses-permission>
    
17.         <uses-permission android:name="android.permission.CHANGE_WIFI_STATE"></uses-permission>
    
18.         <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"></uses-permission>
    
19.         <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"></uses-permission>
    
20. </manifest>

复制代码

布局文件就不贴了，我想看界面你都可以自己写出来，如果有需要，这里可以下载源代码：

转自：http://www.apkbus.com/android-23881-1-1.html