zoukankan      html  css  js  c++  java

  • Android WiFi/WiFi热点开发总结

    首先看一下WiFi的自我介绍：

    Wi-Fi是一种允许电子设备连接到一个无线局域网（WLAN）的技术，通常使用2.4G UHF或5G SHF ISM 射频频段。连接到无线局域网通常是有密码保护的；但也可是开放的，这样就允许任何在WLAN范围内的设备可以连接上。

    wifi可以说是Android开发中非常重要的一部分了，这里用到了一个WifiAdmin工具类。

    ?
    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
    package com.qdzn.home.wifi;
     
    import android.content.Context;
    import android.net.wifi.ScanResult;
    import android.net.wifi.WifiConfiguration;
    import android.net.wifi.WifiInfo;
    import android.net.wifi.WifiManager;
    import android.net.wifi.WifiManager.WifiLock;
     
    import java.lang.reflect.Method;
    import java.util.List;
     
    /**
     * wifi工具类
     */
    public class WifiAdmin {
     
        public static final String SSID = "nexus";
        public static final String PassWord = "12345678";
        private WifiManager mWifiManager;
        // 定义WifiInfo对象
        private WifiInfo mWifiInfo;
        // 扫描出的网络连接列表
        private List<scanresult> mWifiList;
        // 网络连接列表
        private List<wificonfiguration> mWifiConfiguration;
        // 定义一个WifiLock
        WifiLock mWifiLock;
     
        // 构造器
        public WifiAdmin(Context context) {
            // 取得WifiManager对象
            mWifiManager = (WifiManager) context
                    .getSystemService(Context.WIFI_SERVICE);
            // 取得WifiInfo对象
            mWifiInfo = mWifiManager.getConnectionInfo();
        }
     
        // 打开WIFI
        public void openWifi() {
            if (!mWifiManager.isWifiEnabled()) {
                mWifiManager.setWifiEnabled(true);
                //开始扫描WIFI
                startScan();
            }
        }
     
        // 关闭WIFI
        public void closeWifi() {
            if (mWifiManager.isWifiEnabled()) {
                mWifiManager.setWifiEnabled(false);
            }
        }
     
        //创建热点
        public void createAp() {
            if (mWifiManager.isWifiEnabled()) {
                mWifiManager.setWifiEnabled(false);
            }
            try {
                WifiConfiguration apConfiguration = new WifiConfiguration();
                apConfiguration.SSID = WifiAdmin.SSID;
                apConfiguration.preSharedKey = WifiAdmin.PassWord;
                apConfiguration.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
                Method method = mWifiManager.getClass().getMethod("setWifiApEnabled", WifiConfiguration.class, boolean.class);
                method.invoke(mWifiManager, apConfiguration, true);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
     
        /**
         * 关闭WiFi热点
         */
        public void closeWifiAp() {
            if (isWifiApEnabled()) {
                try {
                    Method method = mWifiManager.getClass().getMethod("getWifiApConfiguration");
                    method.setAccessible(true);
                    WifiConfiguration config = (WifiConfiguration) method.invoke(mWifiManager);
                    Method method2 = mWifiManager.getClass().getMethod("setWifiApEnabled", WifiConfiguration.class, boolean.class);
                    method2.invoke(mWifiManager, config, false);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
     
        /**
         * 判断热点是否打开
         *
         * @return
         */
        public boolean isWifiApEnabled() {
            try {
                Method method = mWifiManager.getClass().getMethod("isWifiApEnabled");
                method.setAccessible(true);
                return (Boolean) method.invoke(mWifiManager);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return false;
        }
     
        // 检查当前WIFI状态
        public int checkState() {
            return mWifiManager.getWifiState();
        }
     
        // 锁定WifiLock
        public void acquireWifiLock() {
            mWifiLock.acquire();
        }
     
        // 解锁WifiLock
        public void releaseWifiLock() {
            // 判断时候锁定
            if (mWifiLock.isHeld()) {
                mWifiLock.acquire();
            }
        }
     
        // 创建一个WifiLock
        public void creatWifiLock() {
            mWifiLock = mWifiManager.createWifiLock("Test");
        }
     
        // 得到配置好的网络
        public List<wificonfiguration> getConfiguration() {
            return mWifiConfiguration;
        }
     
        // 指定配置好的网络进行连接
        public void connectConfiguration(int index) {
            // 索引大于配置好的网络索引返回
            if (index > mWifiConfiguration.size()) {
                return;
            }
            // 连接配置好的指定ID的网络
            mWifiManager.enableNetwork(mWifiConfiguration.get(index).networkId, true);
        }
     
        /**
         * 扫描WIFI
         */
        public void startScan() {
            mWifiManager.startScan();
            // 得到扫描结果
            mWifiList = mWifiManager.getScanResults();
            // 得到配置好的网络连接
            mWifiConfiguration = mWifiManager.getConfiguredNetworks();
        }
     
        // 得到网络列表
        public List<scanresult> getWifiList() {
            return mWifiList;
        }
     
        // 查看扫描结果
        public StringBuilder lookUpScan() {
            StringBuilder stringBuilder = new StringBuilder();
            for (int i = 0; i < mWifiList.size(); i++) {
                stringBuilder
                        .append("Index_" + new Integer(i + 1).toString() + ":");
                // 将ScanResult信息转换成一个字符串包
                // 其中把包括：BSSID、SSID、capabilities、frequency、level
                stringBuilder.append((mWifiList.get(i)).toString());
                stringBuilder.append("/n");
            }
            return stringBuilder;
        }
     
        // 得到MAC地址
        public String getMacAddress() {
            return (mWifiInfo == null) ? "NULL" : mWifiInfo.getMacAddress();
        }
     
        // 得到接入点的BSSID
        public String getBSSID() {
            return (mWifiInfo == null) ? "NULL" : mWifiInfo.getBSSID();
        }
     
        // 得到IP地址
        public int getIPAddress() {
            return (mWifiInfo == null) ? 0 : mWifiInfo.getIpAddress();
        }
     
        // 得到连接的ID
        public int getNetworkId() {
            return (mWifiInfo == null) ? 0 : mWifiInfo.getNetworkId();
        }
     
        // 得到WifiInfo的所有信息包
        public String getWifiInfo() {
            return (mWifiInfo == null) ? "NULL" : mWifiInfo.toString();
        }
     
        // 添加一个网络并连接
        public void addNetwork(WifiConfiguration wcg) {
            System.out.println("进行添加网络：");
            int wcgID = mWifiManager.addNetwork(wcg);
            boolean b = mWifiManager.enableNetwork(wcgID, true);
            System.out.println("b--" + b);
        }
     
        // 断开指定ID的网络
        public void disconnectWifi(int netId) {
            mWifiManager.disableNetwork(netId);
            mWifiManager.disconnect();
        }
     
        // 然后是一个实际应用方法
        public WifiConfiguration CreateWifiInfo(String SSID, String Password, int Type) {
            WifiConfiguration config = new WifiConfiguration();
            config.allowedAuthAlgorithms.clear();
            config.allowedGroupCiphers.clear();
            config.allowedKeyManagement.clear();
            config.allowedPairwiseCiphers.clear();
            config.allowedProtocols.clear();
            config.SSID = """ + SSID + """;
            WifiConfiguration tempConfig = this.IsExsits(SSID);
            if (tempConfig != null) {
                mWifiManager.removeNetwork(tempConfig.networkId);
            }
     
            if (Type == 1) // WIFICIPHER_NOPASS
            {
                config.wepKeys[0] = "";
                config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
                config.wepTxKeyIndex = 0;
            }
            if (Type == 2) // WIFICIPHER_WEP
            {
                config.hiddenSSID = true;
                config.wepKeys[0] = """ + Password + """;
                config.allowedAuthAlgorithms
                        .set(WifiConfiguration.AuthAlgorithm.SHARED);
                config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
                config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
                config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);
                config.allowedGroupCiphers
                        .set(WifiConfiguration.GroupCipher.WEP104);
                config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
                config.wepTxKeyIndex = 0;
            }
            if (Type == 3) // WIFICIPHER_WPA
            {
                config.preSharedKey = """ + Password + """;
                config.hiddenSSID = true;
                config.allowedAuthAlgorithms
                        .set(WifiConfiguration.AuthAlgorithm.OPEN);
                config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
                config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
                config.allowedPairwiseCiphers
                        .set(WifiConfiguration.PairwiseCipher.TKIP);
                // config.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
                config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
                config.allowedPairwiseCiphers
                        .set(WifiConfiguration.PairwiseCipher.CCMP);
                config.status = WifiConfiguration.Status.ENABLED;
            }
     
            return config;
        }
     
        private WifiConfiguration IsExsits(String SSID) {
            List<wificonfiguration> existingConfigs = mWifiManager
                    .getConfiguredNetworks();
            for (WifiConfiguration existingConfig : existingConfigs) {
                System.out.println(existingConfig.SSID);
                if (existingConfig.SSID.equals(""" + SSID + """)) {
                    System.out.println("拿到了相同配置对象：" + existingConfig.SSID);
                    return existingConfig;
                }
            }
            return null;
        }
     
        /**
         * ip地址转换
         * @param i
         * @return
         */
        public static String intToIp(int i) {
            return (i & 0xFF) + "." + ((i >> 8) & 0xFF) + "." + ((i >> 16) & 0xFF) + "." + ((i >> 24) & 0xFF);
        }
    }</wificonfiguration></scanresult></wificonfiguration></wificonfiguration></scanresult>

    使用方法

    1.初始化工具类

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    //首先需要获取到wifi管理者，初始化工具类
     WifiAdmin wifiAdmin = new WifiAdmin(this);
     
      // 工具类初始化
        public WifiAdmin(Context context) {
            // 取得WifiManager对象
            mWifiManager = (WifiManager) context
                    .getSystemService(Context.WIFI_SERVICE);
            // 取得WifiInfo对象
            mWifiInfo = mWifiManager.getConnectionInfo();
        }

    2.开启wifi

    ?
    1
    2
    //打开wifi
    wifiAdmin.openWifi()；

    3.连接热点

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    //连接热点之前我们需要先扫描周围热点
       public void connect() {
       wifiAdmin.startScan();
           new Thread(new Runnable() {
               @Override
               public void run() {
                              wifiAdmin.addNetwork(wifiAdmin.CreateWifiInfo(WifiAdmin.SSID, WifiAdmin.PassWord, 3));
               }
           }).start();
     
       }

    4.关闭Wifi

    ?
    1
    wifiAdmin.closeWifi();

    5.创建热点

    ?
    1
    wifiAdmin.createAp();

    6.关闭热点

    ?
    1
    wifiAdmin.closeWifiAp();

    对于Wifi和Wifi热点的基本使用就这些，重点都在WifiAdmin工具类中，下面在来说说如何使用广播来监听他们的状态改变。

    注册广播监听WIFI连接状态改变

    1 . 需要的权限

    ?
    1
    2
    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE">
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"></uses-permission></uses-permission>

    2 . 注册广播

    ?
    1
    2
    3
    4
    5
    6
    7
    <receiver android="" name=".WifiReceiver">
         <intent-filter>
              
              
              
         </action></action></action></intent-filter>
    </receiver>

    3 . 广播接收者

    ?
    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
    public class WifiReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            if (intent.getAction().equals(WifiManager.NETWORK_STATE_CHANGED_ACTION)) {
                NetworkInfo info =intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);
                if (info.getState().equals(NetworkInfo.State.DISCONNECTED)) {
                    /**
                     * wifi断开连接
                     */
                } else if (info.getState().equals(NetworkInfo.State.CONNECTED)) {
                    WifiManager wifiManager=(WifiManager)context.getSystemService(Context.WIFI_SERVICE);
                    WifiInfo wifiInfo = wifiManager.getConnectionInfo();
                    /**
                     * wifi以连接wifiInfo.getSSID();获取连接的wifi名称
                     */
                         Log.d("TAG",wifiInfo.getSSID());
                    }
                }else if(intent.getAction().equals(WifiManager.WIFI_STATE_CHANGED_ACTION)) {//wifi打开与否
                int wifistate = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE, WifiManager.WIFI_STATE_DISABLED);
                if (wifistate == WifiManager.WIFI_STATE_DISABLED) {
                    /**
                     * 系统关闭wifi
                     */
                } else if (wifistate == WifiManager.WIFI_STATE_ENABLED) {
                    /**
                     * 系统开启wifi
                     */
                }
            }
        }
    }

    以上就是根据广播接受者来获取WIFI的状态，下面在来说说监听WIFI热点的状态

    1.广播注册(需要注意的是这个Action自动提示里根本就找不到，貌似是被隐藏了起来)

    ?
    1
    2
    3
    4
    5
    <receiver android:name="com.qdzn.home.wifi.WifiApReceiver">
        <intent-filter>
             
        </action></intent-filter>
    </receiver>

    2 . 广播接收者

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    public class WifiApReceiver extends BroadcastReceiver {
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            if ("android.net.wifi.WIFI_AP_STATE_CHANGED".equals(action)) {
                //便携式热点的状态为：10---正在关闭；11---已关闭；12---正在开启；13---已开启
                int state = intent.getIntExtra("wifi_state", 0);
                Log.d("TAG", state + "---");
            }
        }
    }

    以上就是使用广播接收者来获取WIFI和WIFI热点的状态……
  • 相关阅读:
    js正则验证邮箱格式
    PHP面向对象简易验证码类
    php 中 instanceof 操作符
    防止SQL注入
    通过实例详细讲解PHP垃圾回收机制
    PHP实现上传视频的功能
    二维数组分组
    时间戳转换为几分钟、几小时、几天、几周、几月、几年前
    自定义接口错误响应格式
    laravel写crontab定时任务（发送邮件）和laravel crontab不执行的问题
  • 原文地址：https://www.cnblogs.com/Free-Thinker/p/7550649.html
Copyright © 2011-2022 走看看