Android连接WIFI

2401_89693875

于 2024-12-17 04:37:59 发布

阅读量166

点赞数 6

文章标签： android java 开发语言

本文链接：https://blog.youkuaiyun.com/2401_89693875/article/details/144522259

版权

直接连接配置过的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;

}

删除配置

====