Android 连接Wifi和创建Wifi热点 demo

1. android的热点功能不可见，用了反射的技术搞定之外。

1. Eclipse设置语言为utf-8才能查看中文注释

上代码：

MainActivity.java

1. package com.widget.hotspot;
2. import android.os.Bundle;
3. import android.app.Activity;
4. import android.content.BroadcastReceiver;
5. import android.content.Context;
6. import android.content.Intent;
7. import android.content.IntentFilter;
8. import android.util.Log;
9. import android.view.Menu;
10. import android.view.View;
11. import android.widget.Button;
12. public class MainActivity extends Activity {
13. public static final String TAG = "MainActivity";
14. private Button mBtn1, mBtn2;
15. private WifiAdmin mWifiAdmin;
16. private Context mContext = null;
17. @Override
18. protected void onCreate(Bundle savedInstanceState) {
19. super.onCreate(savedInstanceState);
20. mContext = this;
21. setContentView(R.layout.activity_main);
22. mBtn1 = (Button)findViewById(R.id.button1);
23. mBtn2 = (Button)findViewById(R.id.button2);
24. mBtn1.setText("点击连接Wifi");
25. mBtn2.setText("点击创建Wifi热点");
26. mBtn1.setOnClickListener(new Button.OnClickListener() {
27. @Override
28. public void onClick(View v) {
29. // TODO Auto-generated method stub
30. mWifiAdmin = new WifiAdmin(mContext) {
31. @Override
32. public void myUnregisterReceiver(BroadcastReceiver receiver) {
33. // TODO Auto-generated method stub
34. MainActivity.this.unregisterReceiver(receiver);
35. }
36. @Override
37. public Intent myRegisterReceiver(BroadcastReceiver receiver,
38. IntentFilter filter) {
39. // TODO Auto-generated method stub
40. MainActivity.this.registerReceiver(receiver, filter);
41. return null;
42. }
43. @Override
44. public void onNotifyWifiConnected() {
45. // TODO Auto-generated method stub
46. Log.v(TAG, "have connected success!");
47. Log.v(TAG, "###############################");
48. }
49. @Override
50. public void onNotifyWifiConnectFailed() {
51. // TODO Auto-generated method stub
52. Log.v(TAG, "have connected failed!");
53. Log.v(TAG, "###############################");
54. }
55. };
56. mWifiAdmin.openWifi();
57. mWifiAdmin.addNetwork(mWifiAdmin.createWifiInfo("YOU_WIFI", "MM123456", WifiAdmin.TYPE_WPA));
58. }
59. });
60. mBtn2.setOnClickListener(new Button.OnClickListener() {
61. @Override
62. public void onClick(View v) {
63. // TODO Auto-generated method stub
64. WifiApAdmin wifiAp = new WifiApAdmin(mContext);
65. wifiAp.startWifiAp("\"HotSpot\"", "hhhhhh123");
66. }
67. });
68. }
69. @Override
70. public boolean onCreateOptionsMenu(Menu menu) {
71. // Inflate the menu; this adds items to the action bar if it is present.
72. getMenuInflater().inflate(R.menu.activity_main, menu);
73. return true;
74. }
75. @Override
76. public void onResume() {
77. super.onResume();
78. Log.d("Rssi", "Registered");
79. }
80. @Override
81. public void onPause() {
82. super.onPause();
83. Log.d("Rssi", "Unregistered");
84. }
85. }

WifiAdmin.java

参考了：//http://blog.csdn.net/yuanbohx/article/details/8109042

1. package com.widget.hotspot;
2. import java.util.List;
3. import java.util.Timer;
4. import java.util.TimerTask;
5. import android.content.BroadcastReceiver;
6. import android.content.Context;
7. import android.content.Intent;
8. import android.content.IntentFilter;
9. import android.net.ConnectivityManager;
10. import android.net.NetworkInfo;
11. import android.net.NetworkInfo.DetailedState;
12. import android.net.wifi.ScanResult;
13. import android.net.wifi.WifiConfiguration;
14. import android.net.wifi.WifiInfo;
15. import android.net.wifi.WifiManager;
16. import android.net.wifi.WifiManager.WifiLock;
17. import android.util.Log;
18. public abstract class WifiAdmin {
19. private static final String TAG = "WifiAdmin";
20. private WifiManager mWifiManager;
21. private WifiInfo mWifiInfo;
22. // 扫描出的网络连接列表
23. private List<ScanResult> mWifiList;
24. private List<WifiConfiguration> mWifiConfiguration;
25. private WifiLock mWifiLock;
26. private String mPasswd = "";
27. private String mSSID = "";
28. private Context mContext = null;
29. public WifiAdmin(Context context) {
30. mContext = context;
31. // 取得WifiManager对象
32. mWifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
33. // 取得WifiInfo对象
34. mWifiInfo = mWifiManager.getConnectionInfo();
35. Log.v(TAG, "getIpAddress = " + mWifiInfo.getIpAddress());
36. }
37. // 打开WIFI
38. public void openWifi() {
39. if (!mWifiManager.isWifiEnabled()) {
40. mWifiManager.setWifiEnabled(true);
41. }
42. }
43. // 关闭WIFI
44. public void closeWifi() {
45. if (mWifiManager.isWifiEnabled()) {
46. mWifiManager.setWifiEnabled(false);
47. }
48. }
49. public abstract Intent myRegisterReceiver(BroadcastReceiver receiver, IntentFilter filter);
50. public abstract void myUnregisterReceiver(BroadcastReceiver receiver);
51. public abstract void onNotifyWifiConnected();
52. public abstract void onNotifyWifiConnectFailed();
53. // 添加一个网络并连接
54. public void addNetwork(WifiConfiguration wcg) {
55. register();
56. WifiApAdmin.closeWifiAp(mContext);
57. int wcgID = mWifiManager.addNetwork(wcg);
58. boolean b = mWifiManager.enableNetwork(wcgID, true);
59. }
60. public static final int TYPE_NO_PASSWD = 0x11;
61. public static final int TYPE_WEP = 0x12;
62. public static final int TYPE_WPA = 0x13;
63. public void addNetwork(String ssid, String passwd, int type) {
64. if (ssid == null || passwd == null || ssid.equals("")) {
65. Log.e(TAG, "addNetwork() ## nullpointer error!");
66. return;
67. }
68. if (type != TYPE_NO_PASSWD && type != TYPE_WEP && type != TYPE_WPA) {
69. Log.e(TAG, "addNetwork() ## unknown type = " + type);
70. }
71. stopTimer();
72. unRegister();
73. addNetwork(createWifiInfo(ssid, passwd, type));
74. }
75. private BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {
76. @Override
77. public void onReceive(Context context, Intent intent) {
78. // TODO Auto-generated method stub
79. if (intent.getAction().equals(WifiManager.RSSI_CHANGED_ACTION)) {
80. Log.d(TAG, "RSSI changed");
81. //有可能是正在获取，或者已经获取了
82. Log.d(TAG, " intent is " + WifiManager.RSSI_CHANGED_ACTION);
83. if (isWifiContected(mContext) == WIFI_CONNECTED) {
84. stopTimer();
85. onNotifyWifiConnected();
86. unRegister();
87. } else if (isWifiContected(mContext) == WIFI_CONNECT_FAILED) {
88. stopTimer();
89. closeWifi();
90. onNotifyWifiConnectFailed();
91. unRegister();
92. } else if (isWifiContected(mContext) == WIFI_CONNECTING) {
93. }
94. }
95. }
96. };
97. private final int STATE_REGISTRING = 0x01;
98. private final int STATE_REGISTERED = 0x02;
99. private final int STATE_UNREGISTERING = 0x03;
100. private final int STATE_UNREGISTERED = 0x04;
101. private int mHaveRegister = STATE_UNREGISTERED;
102. private synchronized void register() {
103. Log.v(TAG, "register() ##mHaveRegister = " + mHaveRegister);
104. if (mHaveRegister == STATE_REGISTRING
105. || mHaveRegister == STATE_REGISTERED) {
106. return ;
107. }
108. mHaveRegister = STATE_REGISTRING;
109. myRegisterReceiver(mBroadcastReceiver, new IntentFilter(WifiManager.RSSI_CHANGED_ACTION));
110. mHaveRegister = STATE_REGISTERED;
111. startTimer();
112. }
113. private synchronized void unRegister() {
114. Log.v(TAG, "unRegister() ##mHaveRegister = " + mHaveRegister);
115. if (mHaveRegister == STATE_UNREGISTERED
116. || mHaveRegister == STATE_UNREGISTERING) {
117. return ;
118. }
119. mHaveRegister = STATE_UNREGISTERING;
120. myUnregisterReceiver(mBroadcastReceiver);
121. mHaveRegister = STATE_UNREGISTERED;
122. }
123. private Timer mTimer = null;
124. private void startTimer() {
125. if (mTimer != null) {
126. stopTimer();
127. }
128. mTimer = new Timer(true);
129. //      mTimer.schedule(mTimerTask, 0, 20 * 1000);// 20s
130. mTimer.schedule(mTimerTask, 30 * 1000);
131. }
132. private TimerTask mTimerTask = new TimerTask() {
133. @Override
134. public void run() {
135. // TODO Auto-generated method stub
136. Log.e(TAG, "timer out!");
137. onNotifyWifiConnectFailed();
138. unRegister();
139. }
140. };
141. private void stopTimer() {
142. if (mTimer != null) {
143. mTimer.cancel();
144. mTimer = null;
145. }
146. }
147. @Override
148. protected void finalize() {
149. try {
150. super.finalize();
151. unRegister();
152. } catch (Throwable e) {
153. // TODO Auto-generated catch block
154. e.printStackTrace();
155. }
156. }
157. public WifiConfiguration createWifiInfo(String SSID, String password, int type) {
158. Log.v(TAG, "SSID = " + SSID + "## Password = " + password + "## Type = " + type);
159. WifiConfiguration config = new WifiConfiguration();
160. config.allowedAuthAlgorithms.clear();
161. config.allowedGroupCiphers.clear();
162. config.allowedKeyManagement.clear();
163. config.allowedPairwiseCiphers.clear();
164. config.allowedProtocols.clear();
165. config.SSID = "\"" + SSID + "\"";
166. WifiConfiguration tempConfig = this.IsExsits(SSID);
167. if (tempConfig != null) {
168. mWifiManager.removeNetwork(tempConfig.networkId);
169. }
170. // 分为三种情况：1没有密码2用wep加密3用wpa加密
171. if (type == TYPE_NO_PASSWD) {// WIFICIPHER_NOPASS
172. config.wepKeys[0] = "";
173. config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
174. config.wepTxKeyIndex = 0;
175. } else if (type == TYPE_WEP) {  //  WIFICIPHER_WEP
176. config.hiddenSSID = true;
177. config.wepKeys[0] = "\"" + password + "\"";
178. config.allowedAuthAlgorithms
179. .set(WifiConfiguration.AuthAlgorithm.SHARED);
180. config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
181. config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
182. config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);
183. config.allowedGroupCiphers
184. .set(WifiConfiguration.GroupCipher.WEP104);
185. config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
186. config.wepTxKeyIndex = 0;
187. } else if (type == TYPE_WPA) {   // WIFICIPHER_WPA
188. config.preSharedKey = "\"" + password + "\"";
189. config.hiddenSSID = true;
190. config.allowedAuthAlgorithms
191. .set(WifiConfiguration.AuthAlgorithm.OPEN);
192. config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
193. config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
194. config.allowedPairwiseCiphers
195. .set(WifiConfiguration.PairwiseCipher.TKIP);
196. // config.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
197. config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
198. config.allowedPairwiseCiphers
199. .set(WifiConfiguration.PairwiseCipher.CCMP);
200. config.status = WifiConfiguration.Status.ENABLED;
201. }
202. return config;
203. }
204. public static final int WIFI_CONNECTED = 0x01;
205. public static final int WIFI_CONNECT_FAILED = 0x02;
206. public static final int WIFI_CONNECTING = 0x03;
207. /**
208. * 判断wifi是否连接成功,不是network
209. *
210. * @param context
211. * @return
212. */
213. public int isWifiContected(Context context) {
214. ConnectivityManager connectivityManager = (ConnectivityManager) context
215. .getSystemService(Context.CONNECTIVITY_SERVICE);
216. NetworkInfo wifiNetworkInfo = connectivityManager
217. .getNetworkInfo(ConnectivityManager.TYPE_WIFI);
218. Log.v(TAG, "isConnectedOrConnecting = " + wifiNetworkInfo.isConnectedOrConnecting());
219. Log.d(TAG, "wifiNetworkInfo.getDetailedState() = " + wifiNetworkInfo.getDetailedState());
220. if (wifiNetworkInfo.getDetailedState() == DetailedState.OBTAINING_IPADDR
221. || wifiNetworkInfo.getDetailedState() == DetailedState.CONNECTING) {
222. return WIFI_CONNECTING;
223. } else if (wifiNetworkInfo.getDetailedState() == DetailedState.CONNECTED) {
224. return WIFI_CONNECTED;
225. } else {
226. Log.d(TAG, "getDetailedState() == " + wifiNetworkInfo.getDetailedState());
227. return WIFI_CONNECT_FAILED;
228. }
229. }
230. private WifiConfiguration IsExsits(String SSID) {
231. List<WifiConfiguration> existingConfigs = mWifiManager.getConfiguredNetworks();
232. for (WifiConfiguration existingConfig : existingConfigs) {
233. if (existingConfig.SSID.equals("\"" + SSID + "\"") /*&& existingConfig.preSharedKey.equals("\"" + password + "\"")*/) {
234. return existingConfig;
235. }
236. }
237. return null;
238. }
239. // 断开指定ID的网络
240. public void disconnectWifi(int netId) {
241. mWifiManager.disableNetwork(netId);
242. mWifiManager.disconnect();
243. }
244. // 检查当前WIFI状态
245. public int checkState() {
246. return mWifiManager.getWifiState();
247. }
248. // 锁定WifiLock
249. public void acquireWifiLock() {
250. mWifiLock.acquire();
251. }
252. // 解锁WifiLock
253. public void releaseWifiLock() {
254. // 判断时候锁定
255. if (mWifiLock.isHeld()) {
256. mWifiLock.acquire();
257. }
258. }
259. // 创建一个WifiLock
260. public void creatWifiLock() {
261. mWifiLock = mWifiManager.createWifiLock("Test");
262. }
263. // 得到配置好的网络
264. public List<WifiConfiguration> getConfiguration() {
265. return mWifiConfiguration;
266. }
267. // 指定配置好的网络进行连接
268. public void connectConfiguration(int index) {
269. // 索引大于配置好的网络索引返回
270. if (index > mWifiConfiguration.size()) {
271. return;
272. }
273. // 连接配置好的指定ID的网络
274. mWifiManager.enableNetwork(mWifiConfiguration.get(index).networkId,
275. true);
276. }
277. public void startScan() {
278. mWifiManager.startScan();
279. mWifiList = mWifiManager.getScanResults();
280. mWifiConfiguration = mWifiManager.getConfiguredNetworks();
281. }
282. // 得到网络列表
283. public List<ScanResult> getWifiList() {
284. return mWifiList;
285. }
286. // 查看扫描结果
287. public StringBuilder lookUpScan() {
288. StringBuilder stringBuilder = new StringBuilder();
289. for (int i = 0; i < mWifiList.size(); i++) {
290. stringBuilder
291. .append("Index_" + new Integer(i + 1).toString() + ":");
292. // 将ScanResult信息转换成一个字符串包
293. // 其中把包括：BSSID、SSID、capabilities、frequency、level
294. stringBuilder.append((mWifiList.get(i)).toString());
295. stringBuilder.append("/n");
296. }
297. return stringBuilder;
298. }
299. // 得到MAC地址
300. public String getMacAddress() {
301. return (mWifiInfo == null) ? "NULL" : mWifiInfo.getMacAddress();
302. }
303. // 得到接入点的BSSID
304. public String getBSSID() {
305. return (mWifiInfo == null) ? "NULL" : mWifiInfo.getBSSID();
306. }
307. // 得到IP地址
308. public int getIPAddress() {
309. return (mWifiInfo == null) ? 0 : mWifiInfo.getIpAddress();
310. }
311. // 得到连接的ID
312. public int getNetworkId() {
313. return (mWifiInfo == null) ? 0 : mWifiInfo.getNetworkId();
314. }
315. // 得到WifiInfo的所有信息包
316. public String getWifiInfo() {
317. return (mWifiInfo == null) ? "NULL" : mWifiInfo.toString();
318. }
319. }

WifiApAdmin.java

参考了 http://blog.csdn.net/cxlmax/article/details/7827102

1. package com.widget.hotspot;
2. import java.lang.reflect.InvocationTargetException;
3. import java.lang.reflect.Method;
4. import java.util.Timer;
5. import java.util.TimerTask;
6. import android.content.Context;
7. import android.net.wifi.WifiConfiguration;
8. import android.net.wifi.WifiManager;
9. import android.util.Log;
10. /**
11. * 创建热点
12. *
13. */
14. public class WifiApAdmin {
15. public static final String TAG = "WifiApAdmin";
16. public static void closeWifiAp(Context context) {
17. WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
18. closeWifiAp(wifiManager);
19. }
20. private WifiManager mWifiManager = null;
21. private Context mContext = null;
22. public WifiApAdmin(Context context) {
23. mContext = context;
24. mWifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);
25. closeWifiAp(mWifiManager);
26. }
27. private String mSSID = "";
28. private String mPasswd = "";
29. public void startWifiAp(String ssid, String passwd) {
30. mSSID = ssid;
31. mPasswd = passwd;
32. if (mWifiManager.isWifiEnabled()) {
33. mWifiManager.setWifiEnabled(false);
34. }
35. stratWifiAp();
36. MyTimerCheck timerCheck = new MyTimerCheck() {
37. @Override
38. public void doTimerCheckWork() {
39. // TODO Auto-generated method stub
40. if (isWifiApEnabled(mWifiManager)) {
41. Log.v(TAG, "Wifi enabled success!");
42. this.exit();
43. } else {
44. Log.v(TAG, "Wifi enabled failed!");
45. }
46. }
47. @Override
48. public void doTimeOutWork() {
49. // TODO Auto-generated method stub
50. this.exit();
51. }
52. };
53. timerCheck.start(15, 1000);
54. }
55. public void stratWifiAp() {
56. Method method1 = null;
57. try {
58. method1 = mWifiManager.getClass().getMethod("setWifiApEnabled",
59. WifiConfiguration.class, boolean.class);
60. WifiConfiguration netConfig = new WifiConfiguration();
61. netConfig.SSID = mSSID;
62. netConfig.preSharedKey = mPasswd;
63. netConfig.allowedAuthAlgorithms
64. .set(WifiConfiguration.AuthAlgorithm.OPEN);
65. netConfig.allowedProtocols.set(WifiConfiguration.Protocol.RSN);
66. netConfig.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
67. netConfig.allowedKeyManagement
68. .set(WifiConfiguration.KeyMgmt.WPA_PSK);
69. netConfig.allowedPairwiseCiphers
70. .set(WifiConfiguration.PairwiseCipher.CCMP);
71. netConfig.allowedPairwiseCiphers
72. .set(WifiConfiguration.PairwiseCipher.TKIP);
73. netConfig.allowedGroupCiphers
74. .set(WifiConfiguration.GroupCipher.CCMP);
75. netConfig.allowedGroupCiphers
76. .set(WifiConfiguration.GroupCipher.TKIP);
77. method1.invoke(mWifiManager, netConfig, true);
78. } catch (IllegalArgumentException e) {
79. // TODO Auto-generated catch block
80. e.printStackTrace();
81. } catch (IllegalAccessException e) {
82. // TODO Auto-generated catch block
83. e.printStackTrace();
84. } catch (InvocationTargetException e) {
85. // TODO Auto-generated catch block
86. e.printStackTrace();
87. } catch (SecurityException e) {
88. // TODO Auto-generated catch block
89. e.printStackTrace();
90. } catch (NoSuchMethodException e) {
91. // TODO Auto-generated catch block
92. e.printStackTrace();
93. }
94. }
95. private static void closeWifiAp(WifiManager wifiManager) {
96. if (isWifiApEnabled(wifiManager)) {
97. try {
98. Method method = wifiManager.getClass().getMethod("getWifiApConfiguration");
99. method.setAccessible(true);
100. WifiConfiguration config = (WifiConfiguration) method.invoke(wifiManager);
101. Method method2 = wifiManager.getClass().getMethod("setWifiApEnabled", WifiConfiguration.class, boolean.class);
102. method2.invoke(wifiManager, config, false);
103. } catch (NoSuchMethodException e) {
104. // TODO Auto-generated catch block
105. e.printStackTrace();
106. } catch (IllegalArgumentException e) {
107. // TODO Auto-generated catch block
108. e.printStackTrace();
109. } catch (IllegalAccessException e) {
110. // TODO Auto-generated catch block
111. e.printStackTrace();
112. } catch (InvocationTargetException e) {
113. // TODO Auto-generated catch block
114. e.printStackTrace();
115. }
116. }
117. }
118. private static boolean isWifiApEnabled(WifiManager wifiManager) {
119. try {
120. Method method = wifiManager.getClass().getMethod("isWifiApEnabled");
121. method.setAccessible(true);
122. return (Boolean) method.invoke(wifiManager);
123. } catch (NoSuchMethodException e) {
124. // TODO Auto-generated catch block
125. e.printStackTrace();
126. } catch (Exception e) {
127. e.printStackTrace();
128. }
129. return false;
130. }
131. }

MyTimeCheck.java

1. package com.widget.hotspot;
2. public abstract class MyTimerCheck {
3. private int mCount = 0;
4. private int mTimeOutCount = 1;
5. private int mSleepTime = 1000; // 1s
6. private boolean mExitFlag = false;
7. private Thread mThread = null;
8. /**
9. * Do not process UI work in this.
10. */
11. public abstract void doTimerCheckWork();
12. public abstract void doTimeOutWork();
13. public MyTimerCheck() {
14. mThread = new Thread(new Runnable() {
15. @Override
16. public void run() {
17. // TODO Auto-generated method stub
18. while (!mExitFlag) {
19. mCount++;
20. if (mCount < mTimeOutCount) {
21. doTimerCheckWork();
22. try {
23. mThread.sleep(mSleepTime);
24. } catch (InterruptedException e) {
25. // TODO Auto-generated catch block
26. e.printStackTrace();
27. exit();
28. }
29. } else {
30. doTimeOutWork();
31. }
32. }
33. }
34. });
35. }
36. /**
37. * start
38. * @param times  How many times will check?
39. * @param sleepTime ms, Every check sleep time.
40. */
41. public void start(int timeOutCount, int sleepTime) {
42. mTimeOutCount = timeOutCount;
43. mSleepTime = sleepTime;
44. mThread.start();
45. }
46. public void exit() {
47. mExitFlag = true;
48. }
49. }

xml布局简单不上了，

效果自己试试看打印就知道了