【Android】Android中WIFI开发总结(一)

简介:

原创作品,允许转载,转载时请务必以超链接形式标明文章  原始出处 、作者信息和本声明。否则将追究法律责任。 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),希望能帮助到大家!

相关文章
|
5天前
|
Java Android开发 iOS开发
探索安卓与iOS开发的差异性与互操作性
【7月更文挑战第17天】在移动应用开发的广阔天地中,安卓和iOS这两大操作系统如同双子星座般璀璨夺目。它们各自拥有独特的开发环境、编程语言和用户群体,为开发者提供了不同的挑战和机遇。本文将从多个维度深入剖析安卓与iOS开发的差异性,并探讨它们之间的互操作性如何实现,以期为开发者们提供一份实用的指南。
16 7
|
3天前
|
Java Android开发 Swift
探索iOS与安卓开发的差异与挑战
本文深入探讨了iOS和安卓两大移动操作系统在应用开发领域的不同点及其所面临的挑战。通过对开发环境、编程语言、用户界面设计、性能优化及市场策略的比较分析,揭示了各自平台的独特性以及开发者需要克服的技术与市场障碍。 【7月更文挑战第19天】
|
2天前
|
Java Android开发 iOS开发
探索安卓与iOS开发的差异:平台特性与用户体验的对比分析
【7月更文挑战第19天】在移动开发的广阔天地中,安卓与iOS两大阵营各据一方,它们在开发环境、用户界面设计、性能优化等方面展现出独特的魅力与挑战。本文旨在深入探讨这两个平台在技术开发和用户体验上的根本差异,并分析这些差异如何影响开发者的策略和最终用户的选择。通过比较两者的编程语言、工具、框架以及设计理念,我们将揭示各自平台的优势与局限,为开发者提供实用的参考,并为消费者呈现一个更加清晰的平台选择视角。
|
4天前
|
安全 Java Android开发
探索安卓与iOS开发的差异:构建未来应用的关键考量
【7月更文挑战第18天】在移动应用开发的广阔天地中,安卓和iOS两大平台各领风骚。本文将深入探讨这两个平台在开发过程中的主要差异,包括编程语言、用户界面设计、性能优化、安全性以及市场策略等方面。通过比较分析,旨在为开发者提供决策支持,帮助他们选择最适合自己项目需求的平台,同时考虑到用户体验和市场需求的变化,为未来的应用开发指明方向。
|
4天前
|
监控 开发工具 Android开发
探索安卓与iOS开发的差异:平台特性、工具和市场趋势
在移动应用开发的广阔舞台上,安卓与iOS两大操作系统扮演着主角。它们各自拥有独特的平台特性、开发工具和市场定位,这些差异深刻影响着开发者的决策和产品的最终形态。本文将深入分析这两大平台的关键技术差异,探讨各自的开发环境和工具集,以及它们在市场上的表现和未来的趋势,为开发者提供一个全面的视角,帮助他们在这两个平台上做出更明智的开发选择。
|
2天前
|
开发工具 Android开发 Swift
探索Android与iOS开发的差异与挑战
【7月更文挑战第20天】在移动应用开发的广阔天地中,Android和iOS两大平台如同双子星座,各自闪耀着独特的光芒。本文将深入探讨这两个平台在开发过程中的主要差异,以及开发者面临的技术挑战。我们将从开发环境、编程语言、用户界面设计、性能优化、安全性考量等多个维度展开讨论,旨在为那些即将踏入或已在这片星空下航行的开发者提供一盏明灯。
|
2天前
|
Java Android开发 iOS开发
探索安卓与iOS开发的差异:平台特性与用户体验的对比分析
在移动应用开发的广阔天地中,安卓与iOS两大阵营各自占据着半壁江山。本文将深入探讨这两个平台在开发环境、编程语言、用户界面设计以及性能优化方面的差异,并分析这些差异如何影响最终的用户体验。通过数据支持的案例分析和最新的市场研究,我们将揭示开发者如何在这两个不同的生态系统中做出战略决策,以及这些决策对应用成功的潜在影响。
|
11天前
|
开发工具 Android开发 iOS开发
探索Android与iOS开发的差异与挑战
【7月更文挑战第11天】在移动应用开发的广阔天地中,Android和iOS两大平台如同双子星座般耀眼,各自拥有独特的开发生态和用户群体。本文将深入分析这两个平台的显著差异,从技术架构到开发工具,再到市场定位,揭示它们之间的异同。通过比较,我们不仅能够更好地理解各自的优势和局限,还能洞察未来移动应用开发的趋势。
|
14天前
|
Java Android开发 iOS开发
探索Android与iOS开发的差异:平台选择对项目成功的影响
【7月更文挑战第8天】在移动应用开发的广阔天地中,Android与iOS两大平台各自占据着半壁江山。本文将深入探讨这两个平台在开发环境、用户界面设计、性能优化以及市场覆盖等方面的根本差异,并分析这些差异如何影响项目的成功。通过比较和分析,旨在为开发者在选择平台时提供更全面的视角,帮助他们根据项目需求和目标市场做出更明智的决策。
|
7天前
|
Android开发 Kotlin
kotlin开发安卓app,如何让布局自适应系统传统导航和全面屏导航
使用`navigationBarsPadding()`修饰符实现界面自适应,自动处理底部导航栏的内边距,再加上`.padding(bottom = 10.dp)`设定内容与屏幕底部的距离,以完成全面的布局适配。示例代码采用Kotlin。
44 15