原创作品，允许转载，转载时请务必以超链接形式标明文章 原始出处 、作者信息和本声明。否则将追究法律责任。http://smallwoniu.blog.51cto.com/3911954/1334951

WIFI就是一种无线联网技术，常见的是使用无线路由器。那么在这个无线路由器的信号覆盖的范围内都可以采用WIFI连接的方式进行联网。如果无线路由器连接了一个ADSL线路或其他的联网线路，则又被称为“热点”。

在Android中对Wifi操作，android本身提供了一些有用的包，在android.net.wifi包下面,主要包括以下几个类和接口：

1.ScanResult

主要用来描述已经检测出的接入点，包括接入点的地址，接入点的名称，身份认证，频率，信号强度等信息。其实就是通过wifi 硬件的扫描来获取一些周边的wifi 热点的信息。

2.WifiConfiguration

Wifi网络的配置，包括安全设置等，在我们连通一个wifi 接入点的时候，需要获取到的一些信息。主要包含四个属性：

BSSID：

BSS是一种特殊的Ad-hoc LAN(一种支持点对点访问的无线网络应用模式)的应用，一个无线网络至少由一个连接到有线网络的AP和若干无线工作站组成，这种配置称为一个基本服务装置。一群计算机设定相同的 BSS名称，即可自成一个group，而此BSS名称，即所谓BSSID。通常，手机WLAN中，bssid其实就是无线路由的MAC地址。

networkid：网络ID。
PreSharedKey：无线网络的安全认证模式。
SSID：SSID(Service Set Identif)用于标识无线局域网，SSID不同的无线网络是无法进行互访的。

3.WifiInfo

wifi无线连接的描述，包括（接入点，网络连接状态，隐藏的接入点，IP地址，连接速度，MAC地址，网络ID，信号强度等信息）。这里简单介绍一下WifiManager中常用的方法:

getSSID() 获得SSID（热点名称）

getBSSID()

 获取BSSID
getDetailedStateOf() 获取客户端的连通性
getHiddenSSID() 获得SSID 是否被隐藏
getIpAddress() 获取IP 地址
getLinkSpeed() 获得连接的速度
getMacAddress() 获得Mac 地址
getRssi() 获得802.11n 网络的信号

4.WifiManager

wifi连接统一管理类，获取WIFI网卡的状态(WIFI网卡的状态是由一系列的整形常量来表示的)

WIFI_STATE_DISABLING = 0 WIFI网卡正在关闭
WIFI_STATE_DISABLED = 1 WIFI网卡不可用
WIFI_STATE_ENABLING = 2 WIFI网正在打开 （WIFI启动需要一段时间）
WIFI_STATE_ENABLED = 3 WIFI网卡可用
WIFI_STATE_UNKNOWN = 4 未知网卡状态
WIFI_AP_STATE_DISABLING = 10 WIFI热点正在关闭
WIFI_AP_STATE_DISABLED = 11 WIFI热点不可用
WIFI_AP_STATE_ENABLING = 12 WIFI热点正在打开
WIFI_AP_STATE_ENABLED = 13 WIFI热点可用

5. 在AndroidManifest.xml进行对WIFI操作的权限设置

1
2
3
4
5
<!-- 以下是使用wifi访问网络所需的权限 -->
    <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE"></uses-permission>
  <uses-permission android:name="android.permission.CHANGE_WIFI_STATE"></uses-permission>
  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"></uses-permission>
  <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"></uses-permission>

下面是汇总的一个wifi管理工具类，我完善了一下，并加上了详细的注解，很实用的！

WifiAdmin类： （wifi管理工具类）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
package com.zhf.wifidemo.wifi.utils;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Iterator;
import java.util.List;
import android.content.Context;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
/**
 * WIFI管理类
 * @author ZHF
 *
 */
public class WifiAdmin {
    private static  WifiAdmin wifiAdmin = null;
                                                                                                                                                           
    private List<WifiConfiguration> mWifiConfiguration; //无线网络配置信息类集合(网络连接列表)
    private List<ScanResult> mWifiList; //检测到接入点信息类 集合
                                                                                                                                                           
    //描述任何Wifi连接状态
    private WifiInfo mWifiInfo;
                                                                                                                                                           
    WifiManager.WifiLock mWifilock; //能够阻止wifi进入睡眠状态，使wifi一直处于活跃状态
    public WifiManager mWifiManager;
                                                                                                                                                           
    /**
     * 获取该类的实例（懒汉）
     * @param context
     * @return
     */
    public static WifiAdmin getInstance(Context context) {
        if(wifiAdmin == null) {
            wifiAdmin = new WifiAdmin(context);
            return wifiAdmin;
        }
        return null;
    }
    private WifiAdmin(Context context) {
        //获取系统Wifi服务   WIFI_SERVICE
        this.mWifiManager = (WifiManager) context.getSystemService("wifi");
        //获取连接信息
        this.mWifiInfo = this.mWifiManager.getConnectionInfo();
    }
                                                                                                                                                           
    /**
     * 是否存在网络信息
     * @param str  热点名称
     * @return
     */
    private WifiConfiguration isExsits(String str) {
        Iterator localIterator = this.mWifiManager.getConfiguredNetworks().iterator();
        WifiConfiguration localWifiConfiguration;
        do {
            if(!localIterator.hasNext()) return null;
            localWifiConfiguration = (WifiConfiguration) localIterator.next();
        }while(!localWifiConfiguration.SSID.equals("\"" + str + "\""));
        return localWifiConfiguration;
    }
                                                                                                                                                           
    /**锁定WifiLock，当下载大文件时需要锁定 **/
    public void AcquireWifiLock() {
        this.mWifilock.acquire();
    }
    /**创建一个WifiLock**/
    public void CreateWifiLock() {
        this.mWifilock = this.mWifiManager.createWifiLock("Test");
    }
    /**解锁WifiLock**/
    public void ReleaseWifilock() {
        if(mWifilock.isHeld()) { //判断时候锁定
            mWifilock.acquire();
        }
    }
                                                                                                                                                           
                                                                                                                                                           
    /**打开Wifi**/
    public void OpenWifi() {
        if(!this.mWifiManager.isWifiEnabled()){ //当前wifi不可用
            this.mWifiManager.setWifiEnabled(true);
        }
    }
    /**关闭Wifi**/
    public void closeWifi() {
        if(mWifiManager.isWifiEnabled()) {
            mWifiManager.setWifiEnabled(false);
        }
    }
    /**端口指定id的wifi**/
    public void disconnectWifi(int paramInt) {
        this.mWifiManager.disableNetwork(paramInt);
    }
                                                                                                                                                           
    /**添加指定网络**/
    public void addNetwork(WifiConfiguration paramWifiConfiguration) {
        int i = mWifiManager.addNetwork(paramWifiConfiguration);
        mWifiManager.enableNetwork(i, true);
    }
                                                                                                                                                           
    /**
     * 连接指定配置好的网络
     * @param index 配置好网络的ID
     */
    public void connectConfiguration(int index) {
        // 索引大于配置好的网络索引返回 
        if (index > mWifiConfiguration.size()) {
            return;
        }
        //连接配置好的指定ID的网络 
        mWifiManager.enableNetwork(mWifiConfiguration.get(index).networkId, true);
    }
                                                                                                                                                           
    /**
     * 根据wifi信息创建或关闭一个热点
     * @param paramWifiConfiguration
     * @param paramBoolean 关闭标志
     */
    public void createWifiAP(WifiConfiguration paramWifiConfiguration,boolean paramBoolean) {
        try {
            Class localClass = this.mWifiManager.getClass();
            Class[] arrayOfClass = new Class[2];
            arrayOfClass[0] = WifiConfiguration.class;
            arrayOfClass[1] = Boolean.TYPE;
            Method localMethod = localClass.getMethod("setWifiApEnabled",arrayOfClass);
            WifiManager localWifiManager = this.mWifiManager;
            Object[] arrayOfObject = new Object[2];
            arrayOfObject[0] = paramWifiConfiguration;
            arrayOfObject[1] = Boolean.valueOf(paramBoolean);
            localMethod.invoke(localWifiManager, arrayOfObject);
            return;
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 创建一个wifi信息
     * @param ssid 名称
     * @param passawrd 密码
     * @param paramInt 有3个参数，1是无密码，2是简单密码，3是wap加密
     * @param type 是"ap"还是"wifi"
     * @return
     */
    public WifiConfiguration createWifiInfo(String ssid, String passawrd,int paramInt, String type) {
        //配置网络信息类
        WifiConfiguration localWifiConfiguration1 = new WifiConfiguration();
        //设置配置网络属性
        localWifiConfiguration1.allowedAuthAlgorithms.clear();
        localWifiConfiguration1.allowedGroupCiphers.clear();
        localWifiConfiguration1.allowedKeyManagement.clear();
        localWifiConfiguration1.allowedPairwiseCiphers.clear();
        localWifiConfiguration1.allowedProtocols.clear();
                                                                                                                                                               
        if(type.equals("wt")) { //wifi连接
            localWifiConfiguration1.SSID = ("\"" + ssid + "\"");
            WifiConfiguration localWifiConfiguration2 = isExsits(ssid);
            if(localWifiConfiguration2 != null) {
                mWifiManager.removeNetwork(localWifiConfiguration2.networkId); //从列表中删除指定的网络配置网络
            }
            if(paramInt == 1) { //没有密码
                localWifiConfiguration1.wepKeys[0] = "";
                localWifiConfiguration1.allowedKeyManagement.set(0);
                localWifiConfiguration1.wepTxKeyIndex = 0;
            } else if(paramInt == 2) { //简单密码
                localWifiConfiguration1.hiddenSSID = true;
                localWifiConfiguration1.wepKeys[0] = ("\"" + passawrd + "\"");
            } else { //wap加密
                localWifiConfiguration1.preSharedKey = ("\"" + passawrd + "\"");
                localWifiConfiguration1.hiddenSSID = true;
                localWifiConfiguration1.allowedAuthAlgorithms.set(0);
                localWifiConfiguration1.allowedGroupCiphers.set(2);
                localWifiConfiguration1.allowedKeyManagement.set(1);
                localWifiConfiguration1.allowedPairwiseCiphers.set(1);
                localWifiConfiguration1.allowedGroupCiphers.set(3);
                localWifiConfiguration1.allowedPairwiseCiphers.set(2);
            }
        }else {//"ap" wifi热点
            localWifiConfiguration1.SSID = ssid;
            localWifiConfiguration1.allowedAuthAlgorithms.set(1);
            localWifiConfiguration1.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
            localWifiConfiguration1.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
            localWifiConfiguration1.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);
            localWifiConfiguration1.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP104);
            localWifiConfiguration1.allowedKeyManagement.set(0);
            localWifiConfiguration1.wepTxKeyIndex = 0;
            if (paramInt == 1) {  //没有密码
                localWifiConfiguration1.wepKeys[0] = "";
                localWifiConfiguration1.allowedKeyManagement.set(0);
                localWifiConfiguration1.wepTxKeyIndex = 0;
            } else if (paramInt == 2) { //简单密码
                localWifiConfiguration1.hiddenSSID = true;//网络上不广播ssid
                localWifiConfiguration1.wepKeys[0] = passawrd;
            } else if (paramInt == 3) {//wap加密
                localWifiConfiguration1.preSharedKey = passawrd;
                localWifiConfiguration1.allowedAuthAlgorithms.set(0);
                localWifiConfiguration1.allowedProtocols.set(1);
                localWifiConfiguration1.allowedProtocols.set(0);
                localWifiConfiguration1.allowedKeyManagement.set(1);
                localWifiConfiguration1.allowedPairwiseCiphers.set(2);
                localWifiConfiguration1.allowedPairwiseCiphers.set(1);
            }
        }
        return localWifiConfiguration1;
    }
                                                                                                                                                           
    /**获取热点名**/
    public String getApSSID() {
        try {
            Method localMethod = this.mWifiManager.getClass().getDeclaredMethod("getWifiApConfiguration", new Class[0]);
            if (localMethod == null) return null;
            Object localObject1 = localMethod.invoke(this.mWifiManager,new Object[0]);
            if (localObject1 == null) return null;
            WifiConfiguration localWifiConfiguration = (WifiConfiguration) localObject1;
            if (localWifiConfiguration.SSID != null) return localWifiConfiguration.SSID;
            Field localField1 = WifiConfiguration.class .getDeclaredField("mWifiApProfile");
            if (localField1 == null) return null;
            localField1.setAccessible(true);
            Object localObject2 = localField1.get(localWifiConfiguration);
            localField1.setAccessible(false);
            if (localObject2 == null)  return null;
            Field localField2 = localObject2.getClass().getDeclaredField("SSID");
            localField2.setAccessible(true);
            Object localObject3 = localField2.get(localObject2);
            if (localObject3 == null) return null;
            localField2.setAccessible(false);
            String str = (String) localObject3;
            return str;
        } catch (Exception localException) {
        }
        return null;
    }
                                                                                                                                                           
    /**获取wifi名**/
    public String getBSSID() {
        if (this.mWifiInfo == null)
            return "NULL";
        return this.mWifiInfo.getBSSID();
    }
                                                                                                                                                         
   /**得到配置好的网络 **/
    public List<WifiConfiguration> getConfiguration() {
        return this.mWifiConfiguration;
    }
                                                                                                                                                           
    /**获取ip地址**/
    public int getIPAddress() {
        return (mWifiInfo == null) ? 0 : mWifiInfo.getIpAddress();
    }
    /**获取物理地址(Mac)**/
    public String getMacAddress() {
         return (mWifiInfo == null) ? "NULL" : mWifiInfo.getMacAddress();
    }  
                                                                                                                                                             
    /**获取网络id**/
    public int getNetworkId() {
         return (mWifiInfo == null) ? 0 : mWifiInfo.getNetworkId();
    }
    /**获取热点创建状态**/
    public int getWifiApState() {
        try {
            int i = ((Integer) this.mWifiManager.getClass()
                    .getMethod("getWifiApState", new Class[0])
                    .invoke(this.mWifiManager, new Object[0])).intValue();
            return i;
        } catch (Exception localException) {
        }
        return 4;   //未知wifi网卡状态
    }
    /**获取wifi连接信息**/
    public WifiInfo getWifiInfo() {
        return this.mWifiManager.getConnectionInfo();
    }
    /** 得到网络列表**/
    public List<ScanResult> getWifiList() {
        return this.mWifiList;
    }
                                                                                                                                                         
    /**查看扫描结果**/
    public StringBuilder lookUpScan() {
        StringBuilder localStringBuilder = new StringBuilder();
        for (int i = 0; i < mWifiList.size(); i++)
        {
            localStringBuilder.append("Index_"+new Integer(i + 1).toString() + ":");
            //将ScanResult信息转换成一个字符串包
            //其中把包括：BSSID、SSID、capabilities、frequency、level
            localStringBuilder.append((mWifiList.get(i)).toString());
            localStringBuilder.append("\n");
        }
        return localStringBuilder;
    }
                                                                                                                                                             
    /** 设置wifi搜索结果 **/
    public void setWifiList() {
        this.mWifiList = this.mWifiManager.getScanResults();
    }
    /**开始搜索wifi**/
    public void startScan() {
        this.mWifiManager.startScan();
    }
    /**得到接入点的BSSID**/
    public String GetBSSID() {
        return (mWifiInfo == null) ? "NULL" : mWifiInfo.getBSSID();
    }
}

最后，成功连接到wifi后，通过本机IP地址便可以进行相关网络开发，在下一篇中我会讲解一个WIFI热点搜索、创建、连接的Demo（http://smallwoniu.blog.51cto.com/3911954/1338618）,希望能帮助到大家！

【Android】Android中WIFI开发总结（一）相关推荐

  1. Android studio中NDK开发（四）——使用addr2line分析Crash日志 backtrace

    文章目录 一.前言 二.分析 1.先提取backtrace部分 2.提取对应so库的信息 3.提取错误地址 三.使用addr2line对地址进行转换 1.addr2line工具的路径放在 2.Term ...

  2. Android中WIFI开发总结（一）

    WIFI就是一种无线联网技术,常见的是使用无线路由器.那么在这个无线路由器的信号覆盖的范围内都可以采用WIFI连接的方式进行联网.如果无线路由器连接了一个ADSL线路或其他的联网线路,则又被称为&qu ...

  3. Android Settings 中wifi详情页 隐私默认选中设备mac

    1.概述 在10.0的系统产品开发中,在对ota升级中,由于要固定使用本机mac地址,所以不能让选择默认mac地址,这时就要修改默认设置,保证升级能够成功 2.Settings 中wifi详情页 隐私 ...

  4. 【Android】Android中WIFI开发总结（二）

    原创作品,允许转载,转载时请务必以超链接形式标明文章 原始出处 .作者信息和本声明.否则将追究法律责任.http://smallwoniu.blog.51cto.com/3911954/1338618 ...

  5. qt android 开发之wifi开发篇

    小编简单介绍如何通过调用android API来获取wifi服务( 非常感谢作者安晓辉发布了qt android 核心编程这本书,让我两天搞懂了很多在qt中开发安卓的要领,现在跟大家分享下!至于还没知 ...

  6. android shell 中查询wifi密码信息

    我之前做过一个WIFI密码分享工具专门针对这种需求.但是由于需要设备获取ROOT权限才能正常使用,涉及到个人隐私就没有发布,下面把原理记录下来,方便后面有需要的时候使用. Android设备中wifi ...

  7. Android传感器Motion Sensor开发实验

    目录 一.实验目的 二.实验要求 三.实验原理 (一)第一次实验 1.JDK(Java Development Kit) 2.Android SDK 3.AVD(Android Virtual Dev ...

  8. 深入了解Android系统中的音视频编解码器：MediaCodec

    Media内核源码 Media内核是Android系统中负责音视频处理的核心模块,包括音视频采集.编解码.传输.播放等功能.Media内核源码位于Android源码树的/frameworks/av目录 ...

  9. Android WiFi开发教程（三）——WiFi热点数据传输

    在上一篇文章中介绍了WiFi的搜索和连接,如果你还没阅读过,建议先阅读上一篇Android WiFi开发教程(二)--WiFi的搜索和连接.本篇接着简单介绍手机上如何通过WiFi热点进行数据传输. 跟 ...

最新文章

  1. pytorch中Schedule与warmup_steps的用法
  2. vuex-along解决vuex中存储的数据在页面刷新之后失去的问题
  3. Py之pdfkit：python的库之pdfkit简介、安装、使用方法详细攻略
  4. pythonista3使用说明_Pythonista中文文档：sound
  5. numpy 转置_Numpy基础：数组转置和轴对换
  6. win7系统主板驱动在哪
  7. centos上安装和配置tomcat
  8. 【LINUX系列】之字符串搜索命令
  9. 苹果iOS开发深入浅出Cocoa之类与对象
  10. Flask框架的学习与实战:实战小项目
  11. 通用mrp手机必备新手安装包
  12. 批量标注数量大的地图注记
  13. AtCoder从小白到大神的进阶攻略
  14. python 基础系列（四） — Python中的面向对象
  15. RDS - 远程桌面服务
  16. MathType公式编辑器数学公式、希腊字母和常用操作快捷键[待续ing]
  17. HTML页面背景音乐自动循环播放
  18. Autodesk Revit 2023 三维建模软件中文正式版安装说明
  19. 黑马程序员-Linux系统编程-01
  20. graphiz应用一例：欧洲上古和中世纪民族变迁

热门文章

  1. WebLogic中文博客
  2. 指针06 - 零基础入门学习C语言46
  3. 百度域名出现问题 2010-1-12号的杯具
  4. macos server 恢复安装_Go语言：Docker安装及运行consul节点
  5. Java黑皮书课后题第7章：*7.13（随机数选择器）编写一个方法，返回1到54之间的随机数，但不能是传递到实参中的数。指定如下方法头
  6. 用指向指针方法对N个字符串进行排序并输出
  7. 数据结构课程设计---最长公共子串
  8. 判断给定的二叉树是否为二叉排序树
  9. 列出文件夹下所有文件命令
  10. Deep learning chapter16