快上网专注成都网站设计 成都网站制作 成都网站建设
成都网站建设公司服务热线：028-86922220

网站建设知识

十年网站开发经验 + 多家企业客户 + 靠谱的建站团队

量身定制 + 运营维护+专业推广+无忧售后，网站问题一站解决

AndroidWiFi开发教程之WiFi热点的创建与关闭示例

小编给大家分享一下Android WiFi开发教程之WiFi热点的创建与关闭示例，相信大部分人都还不怎么了解，因此分享这篇文章给大家参考一下，希望大家阅读完这篇文章后大有收获，下面让我们一起去了解一下吧！

创新互联公司专业提供四川服务器托管服务，为用户提供五星数据中心、电信、双线接入解决方案，用户可自行在线购买四川服务器托管服务，并享受7*24小时金牌售后服务。

先上效果图

Android WiFi开发教程之WiFi热点的创建与关闭示例
Android WiFi开发教程之WiFi热点的创建与关闭示例 
Android WiFi开发教程之WiFi热点的创建与关闭示例

Demo功能比较简单，四个按钮、两个文本和一个列表。功能主要有创建WiFi热点，关闭WiFi热点，搜索WiFi，连接WiFi，数据通讯。源码会在教程结尾提供。

本章节主要介绍WiFi热点的创建和关闭

需要用到的权限

WiFi热点的创建

  1. /**
  2.     * 创建Wifi热点
  3.     */
  4. private void createWifiHotspot() {
  5. if (wifiManager.isWifiEnabled()) {
  6. //如果wifi处于打开状态，则关闭wifi,
  7. wifiManager.setWifiEnabled(false);
  8. }
  9. WifiConfiguration config = new WifiConfiguration();
  10. config.SSID = WIFI_HOTSPOT_SSID;
  11. config.preSharedKey = "123456789";
  12. config.hiddenSSID = true;
  13. config.allowedAuthAlgorithms
  14. .set(WifiConfiguration.AuthAlgorithm.OPEN);//开放系统认证
  15. config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
  16. config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
  17. config.allowedPairwiseCiphers
  18. .set(WifiConfiguration.PairwiseCipher.TKIP);
  19. config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
  20. config.allowedPairwiseCiphers
  21. .set(WifiConfiguration.PairwiseCipher.CCMP);
  22. config.status = WifiConfiguration.Status.ENABLED;
  23. //通过反射调用设置热点
  24. try {
  25. Method method = wifiManager.getClass().getMethod(
  26. "setWifiApEnabled", WifiConfiguration.class, Boolean.TYPE);
  27. boolean enable = (Boolean) method.invoke(wifiManager, config, true);
  28. if (enable) {
  29. textview.setText("热点已开启 SSID:" + WIFI_HOTSPOT_SSID + " password:123456789");
  30. } else {
  31. textview.setText("创建热点失败");
  32. }
  33. } catch (Exception e) {
  34. e.printStackTrace();
  35. textview.setText("创建热点失败");
  36. }
  37. }

这里我们需要用到一个很重要的API——WifiManager。源码中是有这么一段介绍：

  1. This class provides the primary API for managing all aspects of Wi-Fi
  2. connectivity. Get an instance of this class by calling
  3. {@link android.content.Context#getSystemService(String) Context.getSystemService(Context.WIFI_SERVICE)}.

可以了解到，我们能够通过WifiManager来管理WiFi的连接。而通过Context.getSystemService(Context.WIFI_SERVICE)就能获取到它的实例。

wifiManager = (WifiManager) getSystemService(Context.WIFI_SERVICE);

在开启热点的时候，我们需要确保WiFi是关闭状态，因为大部分手机都是不支持热点和WiFi是同时开启的。接着就需要创建WifiConfiguration这个类，由于配置我们所要创建的热点的属性。这里我们所需注意的主要是SSID、preSharedKey和KeyMgmt。 分别对应热点的名称、密码和加密方式。

配置完属性后，我们就可以通过Java的反射机制去创建热点。

WiFi热点的关闭

  1. /**
  2.     * 关闭WiFi热点
  3.     */
  4. public void closeWifiHotspot() {
  5. try {
  6. Method method = wifiManager.getClass().getMethod("getWifiApConfiguration");
  7. method.setAccessible(true);
  8. WifiConfiguration config = (WifiConfiguration) method.invoke(wifiManager);
  9. Method method2 = wifiManager.getClass().getMethod("setWifiApEnabled", WifiConfiguration.class, boolean.class);
  10. method2.invoke(wifiManager, config, false);
  11. } catch (NoSuchMethodException e) {
  12. e.printStackTrace();
  13. } catch (IllegalArgumentException e) {
  14. e.printStackTrace();
  15. } catch (IllegalAccessException e) {
  16. e.printStackTrace();
  17. } catch (InvocationTargetException e) {
  18. e.printStackTrace();
  19. }
  20. }

跟创建WiFI热点一样，关闭的时候同样需要用到Java的反射机制。在调用Method的invoke方法时，将最后一个参数改成false就可以了。

Android WiFi开发教程（二）——WiFi的搜索和连接

WiFi的搜索

  1. /* 搜索wifi热点
  2.     */
  3. private void search() {
  4. if (!wifiManager.isWifiEnabled()) {
  5. //开启wifi
  6. wifiManager.setWifiEnabled(true);
  7. }
  8. wifiManager.startScan();
  9. }

我们在开始搜索WiFi之前确保当前WiFi功能是处于开启状态。如果未开启，通过调用WifiManager的setWifiEnabled（boolean enable）去开启。之后调用startScan（）就开始扫描附近的WiFi了。而获取扫描的结果我们就需要创建一个广播接收者来处理。

  1. private BroadcastReceiver receiver = new BroadcastReceiver() {
  2. @Override
  3. public void onReceive(Context context, Intent intent) {
  4. final String action = intent.getAction();
  5. if (action.equals(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION)) {
  6. // wifi已成功扫描到可用wifi。
  7. List
  8. wifiListAdapter.clear();
  9. wifiListAdapter.addAll(scanResults);
  10. }
  11. };

系统在扫描结束后，会发出WifiManager.SCAN_RESULTS_AVAILABLE_ACTION的广播，当我们的接收者接收到这个广播的时候，通过WifiManager的getScanResults（）就能获取到扫描结果的集合了。ScanResult保存着每一个WiFi的信息。这里我将这个集合设置到Adapter中，并在列表中展示出来。下面是Apater中主要的代码：

  1. @Override
  2. public View getView(int position, View convertView, ViewGroup parent) {
  4. if (convertView == null) {
  5. convertView = mInflater.inflate(mResource, parent, false);
  6. }
  8. TextView name = (TextView) convertView.findViewById(R.id.wifi_name);
  9. TextView signl = (TextView) convertView.findViewById(R.id.wifi_signal);
  11. ScanResult scanResult = getItem(position);
  12. name.setText(scanResult.SSID);
  14. int level = scanResult.level;
  15. if (level
  16. signl.setText("信号很好");
  17. } else if (level < -50 && level >= -70) {
  18. signl.setText("信号较好");
  19. } else if (level < -70 && level >= -80) {
  20. signl.setText("信号一般");
  21. } else if (level < -80 && level >= -100) {
  22. signl.setText("信号较差");
  23. } else {
  24. signl.setText("信号很差");
  25. }
  27. return convertView;
  28. }

可以看出列表展示的数据也是比较简单，只有WiFi的名称和信号强度，这两个数据也是平时用得比较多的。获取到扫描结果后，我们就可以处理连接的逻辑了。

WiFi的连接

WiFi的连接相当于搜索就要复杂一些。首先给列表项设置点击事件，获取对应的ScanResult。

  1. listView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
  2. @Override
  3. public void onItemClick(AdapterView
  4. wifiManager.disconnect();
  5. final ScanResult scanResult = wifiListAdapter.getItem(position);
  6. String capabilities = scanResult.capabilities;
  7. int type = WIFICIPHER_WPA;
  8. if (!TextUtils.isEmpty(capabilities)) {
  9. if (capabilities.contains("WPA") || capabilities.contains("wpa")) {
  10. type = WIFICIPHER_WPA;
  11. } else if (capabilities.contains("WEP") || capabilities.contains("wep")) {
  12. type = WIFICIPHER_WEP;
  13. } else {
  14. type = WIFICIPHER_NOPASS;
  15. }
  16. }
  17. config = isExsits(scanResult.SSID);
  18. });

取到ScanResult后我们通过他的capabilities属性判断WiFi的加密方式。接着通过isExsits（String SSID）方法判断系统是否保存着当前WiFi的信息。

  1. private WifiConfiguration isExsits(String SSID) {
  2. List
  3. for (WifiConfiguration existingConfig : existingConfigs) {
  4. if (existingConfig.SSID.equals("\"" + SSID + "\"")) {
  5. return existingConfig;
  6. }
  7. }
  8. return null;
  9. }

如果之前连接过，则返回WiFi的配置信息，否则返回空对象。然后接着处理连接的逻辑

  1. if (config == null) {
  2. if (type != WIFICIPHER_NOPASS) {//需要密码
  3. final EditText editText = new EditText(MainActivity.this);
  4. final int finalType = type;
  5. new AlertDialog.Builder(MainActivity.this).setTitle("请输入Wifi密码").setIcon(
  6. android.R.drawable.ic_dialog_info).setView(
  7. editText).setPositiveButton("确定", new DialogInterface.OnClickListener() {
  8. @Override
  9. public void onClick(DialogInterface dialog, int which) {
  10. Log.w("AAA", "editText.getText():" + editText.getText());
  11. config = createWifiInfo(scanResult.SSID, editText.getText().toString(), finalType);
  12. connect(config);
  13. }
  14. })
  15. .setNegativeButton("取消", null).show();
  16. return;
  17. } else {
  18. config = createWifiInfo(scanResult.SSID, "", type);
  19. connect(config);
  20. }
  21. } else {
  22. connect(config);
  23. }

当没有获取到所要连接WiFi的配置信息时，我们就需要用到前面获取到的加密方式判断是否需要输入密码。如果加密方式为WAP或WEP时，则弹出提示框提示用户输入WiFi密码。用户输入密码后再调用connect(WifiConfiguration config)方法

如果可以获取到所要连接WiFi的配置信息,则直接调用connect(WifiConfiguration config)。

  1. private void connect(WifiConfiguration config) {
  2. int wcgID = wifiManager.addNetwork(config);
  3. wifiManager.enableNetwork(wcgID, true);
  4. }

直接调用WifiManger的addNetwork方法，将配置信息传进去后，会创建一个新的网络描述的身份并返回回来，如果返回来是-1，则表示创建失败。获取到身份后，调用enableNetwork方法就能开始连接WiFi了。到了这里，我们连接部分就完成了一半，接下来需要继续处理WiFi连接过程中返回来的状态。这里同样我们是需要用到广播接收者来处理。

  1. if (action.equals(WifiManager.NETWORK_STATE_CHANGED_ACTION)) {
  2. NetworkInfo info = intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);
  4. if (info.getState().equals(NetworkInfo.State.DISCONNECTED)) {
  5. text_state.setText("连接已断开");
  6. } else if (info.getState().equals(NetworkInfo.State.CONNECTED)) {
  7. WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
  8. final WifiInfo wifiInfo = wifiManager.getConnectionInfo();
  9. text_state.setText("已连接到网络:" + wifiInfo.getSSID());
  11. }
  12. } else {
  13. NetworkInfo.DetailedState state = info.getDetailedState();
  14. if (state == state.CONNECTING) {
  15. text_state.setText("连接中...");
  16. } else if (state == state.AUTHENTICATING) {
  17. text_state.setText("正在验证身份信息...");
  18. } else if (state == state.OBTAINING_IPADDR) {
  19. text_state.setText("正在获取IP地址...");
  20. } else if (state == state.FAILED) {
  21. text_state.setText("连接失败");
  22. }
  23. }
  25. }

上面是广播接收者中的关键代码。WiFi在连接的过程中系统会发出WifiManager.NETWORK_STATE_CHANGED_ACTION的广播，当接收者接收到这条广播时，获取NetworkInfo的state来判断当前的连接状态。状态值分别代表如下

  1. NetworkInfo.State.DISCONNECTED //连接已断开
  2. NetworkInfo.State.CONNECTED //已成功连接

除了这两个状态之外，这里还判断了其他状态

  1. NetworkInfo.DetailedState state = info.getDetailedState();
  2. if (state == state.CONNECTING) {
  3. text_state.setText("连接中...");
  4. } else if (state == state.AUTHENTICATING) {
  5. text_state.setText("正在验证身份信息...");
  6. } else if (state == state.OBTAINING_IPADDR) {
  7. text_state.setText("正在获取IP地址...");
  8. } else if (state == state.FAILED) {
  9. text_state.setText("连接失败");
  10. }

DetailedState中包含了很多连接状态的信息，这里只对部分状态进行处理，其他状态值解析具体如下

  1. IDLE：空闲
  2. SCANNING：正在扫描
  3. CONNECTING：连接中
  4. AUTHENTICATING：正在进行身份验证
  5. OBTAINING_IPADDR：正在获取Ip地址
  6. CONNECTED：已连接
  7. SUSPENDED：已暂停
  8. DISCONNECTING：正在断开连接
  9. DISCONNECTED：已断开
  10. FAILED：失败
  11. BLOCKED：已阻止
  12. VERIFYING_POOR_LINK：暂时关闭（网络状况不佳）
  13. CAPTIVE_PORTAL_CHECK：判断是否需要浏览器二次登录

 

跟蓝牙通讯一样，WiFi热点数据传输也是要运用到Socket。这里我创建了两个线程ConnectThread和ListenerThread，分别去处理数据传输和监听连接。

ConnectThread

  1. **
  2. * 连接线程
  3. * Created by 坤 on 2016/9/7.
  4. */
  5. public class ConnectThread extends Thread{
  7. private final Socket socket;
  8. private Handler handler;
  9. private InputStream inputStream;
  10. private OutputStream outputStream;
  12. public ConnectThread(Socket socket, Handler handler){
  13. setName("ConnectThread");
  14. this.socket = socket;
  15. this.handler = handler;
  16. }
  18. @Override
  19. public void run() {
  20. if(socket==null){
  21. return;
  22. }
  23. handler.sendEmptyMessage(MainActivity.DEVICE_CONNECTED);
  24. try {
  25. //获取数据流
  26. inputStream = socket.getInputStream();
  27. outputStream = socket.getOutputStream();
  29. byte[] buffer = new byte[1024];
  30. int bytes;
  31. while (true){
  32. //读取数据
  33. bytes = inputStream.read(buffer);
  34. if (bytes > 0) {
  35. final byte[] data = new byte[bytes];
  36. System.arraycopy(buffer, 0, data, 0, bytes);
  38. Message message = Message.obtain();
  39. message.what = MainActivity.GET_MSG;
  40. Bundle bundle = new Bundle();
  41. bundle.putString("MSG",new String(data));
  42. message.setData(bundle);
  43. handler.sendMessage(message);
  44. }
  45. }
  46. } catch (IOException e) {
  47. e.printStackTrace();
  48. }
  49. }
  51. /**
  52.     * 发送数据
  53.     */
  54. public void sendData(String msg){
  55. if(outputStream!=null){
  56. try {
  57. outputStream.write(msg.getBytes());
  58. Message message = Message.obtain();
  59. message.what = MainActivity.SEND_MSG_SUCCSEE;
  60. Bundle bundle = new Bundle();
  61. bundle.putString("MSG",new String(msg));
  62. message.setData(bundle);
  63. handler.sendMessage(message);
  64. } catch (IOException e) {
  65. e.printStackTrace();
  66. Message message = Message.obtain();
  67. message.what = MainActivity.SEND_MSG_ERROR;
  68. Bundle bundle = new Bundle();
  69. bundle.putString("MSG",new String(msg));
  70. message.setData(bundle);
  71. handler.sendMessage(message);
  72. }
  73. }
  74. }
  75. }

ConnectThread的构造中，传入了Socket和Handler。Socket用来获取数据以及发送数据，Handler用来更新UI了。在run方法中，我们从Socket中获取到了输入流和输出流，然后循环地读取InputStream的数据，当读取到数据时，则通过Handler将数据更新到UI上。在sendData方法中主要是通过OutputStream写入数据，然后将写入结果通过Handler更新到UI上。

ListenerThread监听线程处理的逻辑就比较简单，通过端口号获取ServerSocket后调用accept（）阻塞线程，直到有设备连接上后就通过Handler更新UI。这里需要注意的是连接上的设备的端口号必须与这里的端口号相同。接着我们看看Hander获取到消息后做了哪些处理。

  1. private Handler handler = new Handler() {
  2. @Override
  3. public void handleMessage(Message msg) {
  4. switch (msg.what) {
  5. case DEVICE_CONNECTING:
  6. connectThread = new ConnectThread(listenerThread.getSocket(),handler);
  7. connectThread.start();
  8. break;
  9. ... ...
  10. }
  11. }
  12. };

可以看到Handler获取到数据后，通过listenerThread.getSocket()将获取到Socket和handler一同创建了ConnectThread实例。

接下来就是用这两个线程来处理数据传输了。

  1. @Override
  2. protected void onCreate(Bundle savedInstanceState) {
  3. super.onCreate(savedInstanceState);
  4. setContentView(R.layout.activity_main);
  5. ... ...
  6. listenerThread = new ListenerThread(PORT, handler);
  7. listenerThread.start();
  8. }

在onCreate中我们创建ListenerThread并启动它，让它监听是否有设备连接上来。当然这里需要先开启WiFi热点后才会有设备连接上来。这是开启热点并等待设备连接的情况。当然我们也可以主动去连接其他开启着热点的设备。

在监听WiFi连接情况的广播接收者中加入下面的代码

  1. if (info.getState().equals(NetworkInfo.State.CONNECTED)) {
  2. WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
  3. final WifiInfo wifiInfo = wifiManager.getConnectionInfo();
  4. text_state.setText("已连接到网络:" + wifiInfo.getSSID());
  6. if (wifiInfo.getSSID().equals(WIFI_HOTSPOT_SSID)) {
  7. //如果当前连接到的wifi是热点,则开启连接线程
  8. new Thread(new Runnable() {
  9. @Override
  10. public void run() {
  11. try {
  12. ArrayList
  13. for (String ip : connectedIP) {
  14. if (ip.contains(".")) {
  16. Socket socket = new Socket(ip, PORT);
  17. connectThread = new ConnectThread(socket, handler);
  18. connectThread.start();
  19. }
  20. }
  22. } catch (IOException e) {
  23. e.printStackTrace();
  24. }
  25. }
  26. }).start();
  27. }
  28. } else {
  29. ...
  30. }
  31. }

这里本地固定了其他设备WiFi热点的SSID,如果当前连接的WiFi的SSID跟我们之前保存的SSID一致，则证明我们连上了我们需要的WiFi热点。然后通过getConnectedIP（）获取WiFi热点的IP地址，通过这个IP地址和端口号创建一个Socket，然后创建ConnectThread来处理数据传输。到这里我们可以看到，PORT和SSID这两个数据是需要两个设备事先协议好的。

最后再看看Handler完整的代码

  1. private Handler handler = new Handler() {
  2. @Override
  3. public void handleMessage(Message msg) {
  4. switch (msg.what) {
  5. case DEVICE_CONNECTING:
  6. connectThread = new ConnectThread(listenerThread.getSocket(),handler);
  7. connectThread.start();
  8. break;
  9. case DEVICE_CONNECTED:
  10. textview.setText("设备连接成功");
  11. break;
  12. case SEND_MSG_SUCCSEE:
  13. textview.setText("发送消息成功:" + msg.getData().getString("MSG"));
  14. break;
  15. case SEND_MSG_ERROR:
  16. textview.setText("发送消息失败:" + msg.getData().getString("MSG"));
  17. break;
  18. case GET_MSG:
  19. textview.setText("收到消息:" + msg.getData().getString("MSG"));
  20. break;
  21. }
  22. }
  23. };

以上是Android WiFi开发教程之WiFi热点的创建与关闭示例的所有内容，感谢各位的阅读！相信大家都有了一定的了解，希望分享的内容对大家有所帮助，如果还想学习更多知识，欢迎关注创新互联行业资讯频道！


分享标题：AndroidWiFi开发教程之WiFi热点的创建与关闭示例
文章网址：http://6mz.cn/article/pccsso.html

其他资讯