Android 连接Wifi和创建Wifi热点 demo

时间：2022-06-16 22:43:09
  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布局简单不上了，

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

相关文章