zoukankan      html  css  js  c++  java
  • 【移动开发】Android中WIFI开发总结(一)

     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 == nullreturn null;
                Object localObject1 = localMethod.invoke(this.mWifiManager,new Object[0]);
                if (localObject1 == nullreturn null;
                WifiConfiguration localWifiConfiguration = (WifiConfiguration) localObject1;
                if (localWifiConfiguration.SSID != nullreturn localWifiConfiguration.SSID;
                Field localField1 = WifiConfiguration.class .getDeclaredField("mWifiApProfile");
                if (localField1 == nullreturn 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 == nullreturn 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(" ");
            }
            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),希望能帮助到大家!

  • 相关阅读:
    概率面试题
    机器学习概率题总结(转载)
    筛素数以及判断数是否是素数
    腾讯2019正式批春笔试题
    推荐系统架构
    文本表示与匹配
    CTR预估经典模型总结
    spark运行原理
    leetcode 字符串动态规划总结
    无向图的邻接矩阵创建代码以及深度遍历广度遍历
  • 原文地址:https://www.cnblogs.com/dongweiq/p/4742137.html
Copyright © 2011-2022 走看看