备案控制台
探索云世界
开发者社区 安全 文章 正文

Android连接WIFI

2016-08-04 990
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 效果图打开WIFI并获取WIFI列表连接到指定WIFI直接连接配置过的WIFI密码错误源码KqwWifiManagerDemoWIFI的获取、连接状态等等的信息，都是通过广播回调的.

效果图

打开WIFI并获取WIFI列表

打开WIFI并获取WIFI列表

连接到指定WIFI

连接到指定WIFI

直接连接配置过的WIFI

直接连接配置过的WIFI

密码错误

密码错误

源码

KqwWifiManagerDemo

WIFI的获取、连接状态等等的信息，都是通过广播回调的.

下面介绍了主要的方法，更多请查看KqwWifiManager

注册广播接收者

<!-- 监听网络状态的广播接收者 -->
<receiver android:name=".KqwWifiManager$NetworkBroadcastReceiver">
    <intent-filter>
        <!-- AP扫描完成，客户端得到可用的结果集 -->
        <action android:name="android.net.wifi.SCAN_RESULTS" />
        <action android:name="android.net.conn.CONNECTIVITY_CHANGE" />
        <action android:name="android.net.wifi.WIFI_STATE_CHANGED" />
        <action android:name="android.net.wifi.STATE_CHANGE" />
        <action android:name="android.net.wifi.supplicant.STATE_CHANGE" />
    </intent-filter>
</receiver>

广播接收者

/**
 * 广播接收者
 */
public static class NetworkBroadcastReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        try {
            String action = intent.getAction();
            Log.i(TAG, "onReceive: action = " + action);
            // 监听WIFI的启用状态
            if (WifiManager.WIFI_STATE_CHANGED_ACTION.equals(action)) {
                int wifiState = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE, 0);
                switch (wifiState) {
                    case WifiManager.WIFI_STATE_ENABLING:
                        Log.i(TAG, "onReceive: 正在打开 WIFI...");
                        break;
                    case WifiManager.WIFI_STATE_ENABLED:
                        Log.i(TAG, "onReceive: WIFI 已打开");
                        if (null != mOnWifiEnabledListener) {
                            mOnWifiEnabledListener.onWifiEnabled(true);
                            mOnWifiEnabledListener.onFinish();
                        }
                        break;
                    case WifiManager.WIFI_STATE_DISABLING:
                        Log.i(TAG, "onReceive: 正在关闭 WIFI...");
                        break;
                    case WifiManager.WIFI_STATE_DISABLED:
                        Log.i(TAG, "onReceive: WIFI 已关闭");
                        if (null != mOnWifiEnabledListener) {
                            mOnWifiEnabledListener.onWifiEnabled(false);
                            mOnWifiEnabledListener.onFinish();
                        }
                        break;
                    case WifiManager.WIFI_STATE_UNKNOWN:
                        Log.i(TAG, "onReceive: WIFI 状态未知!");
                        break;
                    default:
                        break;
                }
            }

            // WIFI扫描完成
            if (WifiManager.SCAN_RESULTS_AVAILABLE_ACTION.equals(action)) {
                if (null != mOnWifiScanResultsListener) {
                    mOnWifiScanResultsListener.onScanResults(getScanResults());
                    mOnWifiScanResultsListener.onFinish();
                }
            }

            // WIFI 连接状态的监听（只有WIFI可用的时候，监听才会有效）
            if (WifiManager.NETWORK_STATE_CHANGED_ACTION.equals(action)) {
                NetworkInfo networkInfo = intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);
                if (null != networkInfo && networkInfo.isConnected()) {
                    WifiInfo wifiInfo = intent.getParcelableExtra(WifiManager.EXTRA_WIFI_INFO);
                    if (null != wifiInfo && String.format("\"%s\"", mConnectingSSID).equals(wifiInfo.getSSID()) && null != mOnWifiConnectListener) {
                        // WIFI连接成功
                        mOnWifiConnectListener.onSuccess(wifiInfo.getSSID());
                        mOnWifiConnectListener.onFinish();
                        mOnWifiConnectListener = null;
                    }
                }
            }

            // WIFI连接过程的监听
            if (intent.getAction().equals(WifiManager.SUPPLICANT_STATE_CHANGED_ACTION)) {
                WifiInfo wifiInfo = mWifiManager.getConnectionInfo();
                SupplicantState state = wifiInfo.getSupplicantState();
                switch (state) {
                    case INTERFACE_DISABLED: // 接口禁用
                        Log.i(TAG, "onReceive: INTERFACE_DISABLED 接口禁用");
                        break;
                    case DISCONNECTED:// 断开连接
                    case INACTIVE: // 不活跃的
                        Log.i(TAG, "onReceive: INACTIVE 不活跃的 DISCONNECTED:// 断开连接");
                        if (null != mOnWifiConnectListener) {
                            // 断开当前网络失败
                            mOnWifiConnectListener.onFailure();
                            // 连接完成
                            mOnWifiConnectListener.onFinish();
                            mOnWifiConnectListener = null;
                            mConnectingSSID = null;
                        }
                        break;
                    case SCANNING: // 正在扫描
                        Log.i(TAG, "onReceive: SCANNING 正在扫描");
                        break;
                    case AUTHENTICATING: // 正在验证
                        Log.i(TAG, "onReceive: AUTHENTICATING: // 正在验证");
                        if (null != mOnWifiConnectListener) {
                            mOnWifiConnectListener.onConnectingMessage("正在验证");
                        }
                        break;
                    case ASSOCIATING: // 正在关联
                        Log.i(TAG, "onReceive: ASSOCIATING: // 正在关联");
                        if (null != mOnWifiConnectListener) {
                            mOnWifiConnectListener.onConnectingMessage("正在关联");
                        }
                        break;
                    case ASSOCIATED: // 已经关联
                        Log.i(TAG, "onReceive: ASSOCIATED: // 已经关联");
                        if (null != mOnWifiConnectListener) {
                            mOnWifiConnectListener.onConnectingMessage("已经关联");
                        }
                        break;
                    case FOUR_WAY_HANDSHAKE:
                        Log.i(TAG, "onReceive: FOUR_WAY_HANDSHAKE:");
                        break;
                    case GROUP_HANDSHAKE:
                        Log.i(TAG, "onReceive: GROUP_HANDSHAKE:");
                        break;
                    case COMPLETED: // 完成
                        Log.i(TAG, "onReceive: COMPLETED: // 完成");
                        if (null != mOnWifiConnectListener) {
                            mOnWifiConnectListener.onConnectingMessage("正在连接...");
                        }
                        break;
                    case DORMANT:
                        Log.i(TAG, "onReceive: DORMANT:");
                        break;
                    case UNINITIALIZED: // 未初始化
                        Log.i(TAG, "onReceive: UNINITIALIZED: // 未初始化");
                        break;
                    case INVALID: // 无效的
                        Log.i(TAG, "onReceive: INVALID: // 无效的");
                        break;
                    default:
                        break;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

权限

<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
<uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
<uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

打开WIFI

/**
 * 打开Wifi
 */
public void openWifi(@NonNull OnWifiEnabledListener listener) {
    if (!mWifiManager.isWifiEnabled()) {
        mOnWifiEnabledListener = listener;
        mOnWifiEnabledListener.onStart(true);
        mWifiManager.setWifiEnabled(true);
    }
}

关闭WIFI

/**
 * 关闭Wifi
 */
public void closeWifi(@NonNull OnWifiEnabledListener listener) {
    if (mWifiManager.isWifiEnabled()) {
        mOnWifiEnabledListener = listener;
        mOnWifiEnabledListener.onStart(false);
        mWifiManager.setWifiEnabled(false);
    }
}

扫描附近的WIFI

/**
 * 扫描附近的WIFI
 *
 * @param listener 扫描完成的回调接口
 */
public void startScan(@NonNull OnWifiScanResultsListener listener) {
    try {
        mOnWifiScanResultsListener = listener;
        mOnWifiScanResultsListener.onStart();
        // 先返回缓存
        mOnWifiScanResultsListener.onScanResults(getScanResults());
        // 重新开始扫描
        mWifiManager.startScan();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

获取WIFI列表

/**
 * 获取Wifi列表
 *
 * @return Wifi列表
 */
private static List<ScanResult> getScanResults() {
    try {
        // 得到扫描结果
        return mWifiManager.getScanResults();
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}

通过密码连接到WIFI

/**
 * 通过密码连接到WIFI
 *
 * @param scanResult 要连接的WIFI
 * @param pwd        密码
 * @param listener   连接的监听
 */
public void connectionWifiByPassword(@NonNull ScanResult scanResult, @Nullable String pwd, @NonNull OnWifiConnectListener listener) {
    // SSID
    String SSID = scanResult.SSID;
    // 加密方式
    SecurityMode securityMode = getSecurityMode(scanResult);

    // 生成配置文件
    WifiConfiguration addConfig = createWifiConfiguration(SSID, pwd, securityMode);
    int netId;
    // 判断当前配置是否存在
    WifiConfiguration updateConfig = isExists(addConfig);
    if (null != updateConfig) {
        // 更新配置
        netId = mWifiManager.updateNetwork(updateConfig);
    } else {
        // 添加配置
        netId = mWifiManager.addNetwork(addConfig);
    }
    // 通过NetworkID连接到WIFI
    connectionWifiByNetworkId(SSID, netId, listener);
}

直接连接配置过的WIFI

/**
 * 通过NetworkId连接到WIFI （配置过的网络可以直接获取到NetworkID，从而不用再输入密码）
 *
 * @param SSID      WIFI名字
 * @param networkId NetworkId
 * @param listener  连接的监听
 */
public void connectionWifiByNetworkId(@NonNull String SSID, int networkId, @NonNull OnWifiConnectListener listener) {
    // 正要连接的SSID
    mConnectingSSID = SSID;
    // 连接的回调监听
    mOnWifiConnectListener = listener;
    // 连接开始的回调
    mOnWifiConnectListener.onStart(SSID);
    /*
     * 判断 NetworkId 是否有效
     * -1 表示配置参数不正确
     */
    if (-1 == networkId) {
        // 连接WIFI失败
        if (null != mOnWifiConnectListener) {
            // 配置错误
            mOnWifiConnectListener.onFailure();
            // 连接完成
            mOnWifiConnectListener.onFinish();
            mOnWifiConnectListener = null;
            mConnectingSSID = null;
        }
        return;
    }
    // 获取当前的网络连接
    WifiInfo wifiInfo = getConnectionInfo();
    if (null != wifiInfo) {
        // 断开当前连接
        boolean isDisconnect = disconnectWifi(wifiInfo.getNetworkId());
        if (!isDisconnect) {
            // 断开当前网络失败
            if (null != mOnWifiConnectListener) {
                // 断开当前网络失败
                mOnWifiConnectListener.onFailure();
                // 连接完成
                mOnWifiConnectListener.onFinish();
                mOnWifiConnectListener = null;
                mConnectingSSID = null;
            }
            return;
        }
    }

    // 连接WIFI
    boolean isEnable = mWifiManager.enableNetwork(networkId, true);
    if (!isEnable) {
        // 连接失败
        if (null != mOnWifiConnectListener) {
            // 连接失败
            mOnWifiConnectListener.onFailure();
            // 连接完成
            mOnWifiConnectListener.onFinish();
            mOnWifiConnectListener = null;
            mConnectingSSID = null;
        }
    }
}

断开指定WIFI

/**
 * 断开WIFI
 *
 * @param netId netId
 * @return 是否断开
 */
public boolean disconnectWifi(int netId) {
    boolean isDisable = mWifiManager.disableNetwork(netId);
    boolean isDisconnect = mWifiManager.disconnect();
    return isDisable && isDisconnect;
}

删除配置

/**
 * 删除配置
 *
 * @param netId netId
 * @return 是否删除成功
 */
private boolean deleteConfig(int netId) {
    boolean isDisable = mWifiManager.disableNetwork(netId);
    boolean isRemove = mWifiManager.removeNetwork(netId);
    boolean isSave = mWifiManager.saveConfiguration();
    return isDisable && isRemove && isSave;
}

生成配置信息

/**
 * 生成新的配置信息 用于连接Wifi
 *
 * @param SSID     WIFI名字
 * @param password WIFI密码
 * @param mode     WIFI加密类型
 * @return 配置
 */
private WifiConfiguration createWifiConfiguration(@NonNull String SSID, @Nullable String password, @NonNull SecurityMode mode) {
    WifiConfiguration config = new WifiConfiguration();
    config.allowedAuthAlgorithms.clear();
    config.allowedGroupCiphers.clear();
    config.allowedKeyManagement.clear();
    config.allowedPairwiseCiphers.clear();
    config.allowedProtocols.clear();
    config.SSID = "\"" + SSID + "\"";

    if (mode == SecurityMode.OPEN) {
        //WIFICIPHER_NOPASS
        // config.wepKeys[0] = "";
        config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
        // config.wepTxKeyIndex = 0;
    } else if (mode == SecurityMode.WEP) {
        //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;
    } else if (mode == SecurityMode.WPA) {
        //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;
}

目前存在的问题

目前存在的问题是，当删除配置以后，再连接WIFI，调用addNetwork或者updateNetwork都会返回-1，需要重启一下WIFI才会正常，有知道原因还请指点一下。

文章标签：
Android开发
数据安全/隐私保护
关键词：
wifi连接
Android连接
Android wifi
wifi android
Android连接wifi
啊啊啊88jdk
目录
相关文章
AirtestProject
|
2月前
|
Android开发
如何用Airtest脚本无线连接Android设备？
如何用Airtest脚本无线连接Android设备？
AirtestProject
35 0
算精通
|
2月前
|
存储 网络安全 Python
WiFi连接树莓派【2月更文挑战第2天】
要通过WiFi连接树莓派并显示其摄像头视频信息，您需要按照以下步骤操作： 1. 确保您的电脑和树莓派已连接到同一个WiFi网络。 2. 安装Python和必要的库：在您的电脑上安装Python 3.6或更高版本，并安装pip（Python包管理器）。然后，通过pip安装以下库： 【2月更文挑战第2天】
算精通
23 1
kind-tester
|
3月前
|
Android开发 Python
Python封装ADB获取Android设备wifi地址的方法
Python封装ADB获取Android设备wifi地址的方法
kind-tester
61 0
晓同哇哇~
|
3月前
|
定位技术 Android开发
uniapp获取wifi连接状态
uniapp获取wifi连接状态
晓同哇哇~
115 0
初学者-Study
|
4月前
|
XML API Android开发
Android WIFI使用简述（上）
Android WIFI使用简述（上）
初学者-Study
72 0
热烈的马
|
4月前
|
Java 关系型数据库 数据库
Android App连接真机步骤与APP的开发语言和工程结构讲解以及运行实例（超详细必看）
Android App连接真机步骤与APP的开发语言和工程结构讲解以及运行实例（超详细必看）
热烈的马
36 0
dreaming317
|
7月前
|
安全 数据安全/隐私保护 网络架构
如何查看电脑所有连接过的wifi密码？
如何查看电脑所有连接过的wifi密码？
dreaming317
281 0
泡沫o0
|
1月前
|
前端开发 安全 数据安全/隐私保护
WPA_CLI 的介绍：介绍如何使用wpa_cli连接WiFi的方法
WPA_CLI 的介绍：介绍如何使用wpa_cli连接WiFi的方法
泡沫o0
37 2
一乐乐
|
5月前
|
安全 数据安全/隐私保护
windows10 查看已连接wifi的密码
windows10 查看已连接wifi的密码
一乐乐
134 0
初学者-Study
|
4月前
|
XML 物联网 API
Android Ble蓝牙App（二）连接与发现服务
Android Ble蓝牙App（二）连接与发现服务
初学者-Study
64 1

热门文章

最新文章

  • 1
    微信小程序如何实现进入小程序自动连WiFi功能
  • 2
    我的Android之路(持续更新总结~)
  • 3
    Android实现自定义进度条(源码+解析)
  • 4
    安卓适配性策略：确保应用在不同设备上的兼容性
  • 5
    构建高效Android应用：探究Kotlin与Java的性能差异
  • 6
    构建高效Android应用：Kotlin协程的实践与优化
  • 7
    安卓安全性指南：保护用户数据免受恶意攻击
  • 8
    构建高效Android应用：探究Kotlin协程的优势
  • 9
    安卓多线程和并发处理：提高应用效率
  • 10
    构建高效Android应用：从优化用户体验到提升性能
  • 1
    云效产品使用常见问题之android sdk 构建出aar后，上传到私有maven仓库失败如何解决
    14
  • 2
    FFmpeg开发笔记（九）Linux交叉编译Android的x265库
    19
  • 3
    构建高效Android应用：从优化用户体验到提升性能表现
    2
  • 4
    构建高效Android应用：采用Kotlin进行内存优化的策略
    5
  • 5
    构建高效的Android应用：内存优化策略
    11
  • 6
    Android网络和数据交互： 请解释Android中的AsyncTask的作用。
    8
  • 7
    Android网络和数据交互： 什么是HTTP和HTTPS？在Android中如何进行网络请求？
    8
  • 8
    安卓即时应用(Instant Apps)开发指南
    17
  • 9
    Android中的动态权限请求与最佳实践
    18
  • 10
    安卓多线程和并发处理：提高应用效率
    29

    • 相关课程

    更多
  • 开源Android容器化框架Atlas开发者指南

    • 相关电子书

    更多
  • 58同城Android客户端Walle框架演进与实践之路
  • 云AP—开启企业WiFi的新零售时代
  • Android组件化实现

    • 推荐镜像

    更多
  • android.googlesource.com
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）