关于wifi连接机制以及WifiManager的使用和监听wifi的方式

最新推荐文章于 2024-08-10 04:15:47 发布
最新推荐文章于 2024-08-10 04:15:47 发布
阅读量3.5k 收藏 8
点赞数 3
分类专栏： 【android】
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/da_caoyuan/article/details/52780570
版权

啥也不说，先贴上代码：

package com.everyoo.utils;

import android.content.Context;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;


import com.everyoo.wifidemon.Constants;

import java.util.List;

/**
 * Created by yuanpeikai on 2015/10/7.
 */
public class WifiUtil {

    private final String TAG = "WifiUtil ";
    // 定义WifiManager对象
    private WifiManager mWifiManager;
    // 定义WifiInfo对象
    private WifiInfo mWifiInfo;
    // 扫描出的网络连接列表
    private List<ScanResult> mWifiList;
    // 网络连接列表
    private List<WifiConfiguration> mWifiConfiguration;
    // 定义一个WifiLock
    WifiManager.WifiLock mWifiLock;

    private static WifiUtil wifiUtil;

    private Context mContext;

    // 构造器
    private WifiUtil(Context context) {
        mContext = context;
        // 取得WifiManager对象
        mWifiManager = (WifiManager) context
                .getSystemService(Context.WIFI_SERVICE);
        // 取得WifiInfo对象
        mWifiInfo = mWifiManager.getConnectionInfo();
    }

    public static synchronized WifiUtil getInstance(Context context) {
        if (wifiUtil == null) {
            wifiUtil = new WifiUtil(context);
        }
        return wifiUtil;
    }

    // 打开WIFI
    public void openWifi() {
        if (!mWifiManager.isWifiEnabled()) {
            mWifiManager.setWifiEnabled(true);
        }
    }

    // 关闭WIFI
    public void closeWifi() {
        if (mWifiManager.isWifiEnabled()) {
            mWifiManager.setWifiEnabled(false);
        }
    }

    public void forgetWifi() {
        List<WifiConfiguration> configurations = mWifiManager.getConfiguredNetworks();
        if (configurations != null && configurations.size() > 0) {
            for (int i = 0; i < configurations.size(); i++) {
                System.out.println("configuration ssid = " + configurations.get(i).SSID);
                mWifiManager.removeNetwork(configurations.get(i).networkId);
            }
            mWifiManager.saveConfiguration();
        } else {
            System.out.println("configurations is null");
        }

    }

    // 检查当前WIFI状态
    public int checkState() {
        return mWifiManager.getWifiState();
    }

    // 锁定WifiLock
    public void acquireWifiLock() {
        mWifiLock.acquire();
    }

    // 解锁WifiLock
    public void releaseWifiLock() {
        // 判断时候锁定
        if (mWifiLock.isHeld()) {
            mWifiLock.release();
        }
    }

    // 创建一个WifiLock
    public void creatWifiLock(int lockType, String tag) {
        mWifiLock = mWifiManager.createWifiLock(lockType, tag);
        mWifiLock.setReferenceCounted(false);// false：不计数锁，即无论调用多少次acquire()，只要调用一次release()即可解锁。
    }


    // 判断网络是否连接
    public boolean isConnecting(Context context) {
        ConnectivityManager mConnectivityManager = (ConnectivityManager) context
                .getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo mNetworkInfo = mConnectivityManager.getActiveNetworkInfo();
        if (mNetworkInfo != null) {
            if (mNetworkInfo.getState() == NetworkInfo.State.CONNECTING) {
                return true;
            }
        }
        return false;
    }

    /**
     * 扫描wifi列表
     */
    public void startScan() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        mWifiManager.startScan();
        // 得到扫描结果
        mWifiList = mWifiManager.getScanResults();
        // 得到配置好的网络连接
        mWifiConfiguration = mWifiManager.getConfiguredNetworks();
    }

    // 得到网络列表
    public List<ScanResult> getWifiList() {
        return mWifiList;
    }

    // 得到配置好的网络
    public List<WifiConfiguration> getConfiguration() {
        return mWifiConfiguration;
    }

    // 指定配置好的网络进行连接
    public void connectConfiguration(int index) {
        // 索引大于配置好的网络索引返回
        if (index > mWifiConfiguration.size()) {
            return;
        }
        // 连接配置好的指定ID的网络
        mWifiManager.enableNetwork(mWifiConfiguration.get(index).networkId,
                true);
    }

    // 查看扫描结果
    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 boolean addNetwork(WifiConfiguration wcg) {
        int wcgID = mWifiManager.addNetwork(wcg);
        boolean b = mWifiManager.enableNetwork(wcgID, false);
        mWifiManager.saveConfiguration();
        System.out.println("a--" + wcgID);
        System.out.println("b--" + b);
        return b;
    }

    // 断开指定ID的网络
    public void disconnectWifi(int netId) {
        mWifiManager.disableNetwork(netId);
        mWifiManager.disconnect();
    }

//然后是一个实际应用方法，只验证过没有密码的情况：分为三种情况：1 没有密码; 2 用wep加密; 3 用wpa加密

    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();
        if (existingConfigs != null) {
            for (WifiConfiguration existingConfig : existingConfigs) {
                if (existingConfig.SSID.equals("\"" + SSID + "\"")) {
                    return existingConfig;
                }
            }

        }
        return null;
    }

    public boolean isExsistsWifiList(String SSID, List<ScanResult> mWifiList) {
        //List<ScanResult> mList = getWifiList();
        if (mWifiList != null) {
            for (ScanResult scanResult : mWifiList) {
                if (scanResult.SSID.equals(SSID)) {
                    return true;
                }
            }
        }
        return false;
    }

    // 判断当前是否有网络
    public boolean isNetworkConnected(Context context) {
        ConnectivityManager mConnectivityManager = (ConnectivityManager) context
                .getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo mNetworkInfo = mConnectivityManager.getActiveNetworkInfo();
        if (mNetworkInfo != null) {
            if (mNetworkInfo.isAvailable() && mNetworkInfo.isConnected()) {
                return true;
            }
        }
        return false;
    }

    public synchronized boolean connectWifi(String ssid, String pwd, int encriptionType) {
        openWifi();
        return addNetwork(createWifiInfo(ssid, pwd, encriptionType));
    }


    public boolean isWifiConnected(Context context) {
        ConnectivityManager mConnectivityManager = (ConnectivityManager) context
                .getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo mNetworkInfo = mConnectivityManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
        if (mNetworkInfo != null && mNetworkInfo.isAvailable() && mNetworkInfo.isConnected()) {
            System.out.println(TAG + "isWifiConnected wifi is connected");
            return true;
        }
        System.out.println(TAG + "isWifiConnected wifi is disconnected");
        return false;
    }


    public void getConfigurations() {
        List<WifiConfiguration> configurations = mWifiManager.getConfiguredNetworks();
        if (configurations != null) {
            for (int i = 0; i < configurations.size(); i++) {
                WifiConfiguration wifiConfiguration = configurations.get(i);
                String ssid = wifiConfiguration.SSID;
                String bssid = wifiConfiguration.BSSID;


            }
        }
    }


    /**
     * 判断wifi的加密方式
     */
    public void parseWifiEncryption() {
        int times = 0;
        int LAST_TIMES = 5;
        while (times < LAST_TIMES) {
            times++;
            openWifi();
            startScan();
            List<ScanResult> scanResultList = getWifiList();
            if (scanResultList != null) {
                for (ScanResult scanResult : scanResultList) {  // 如果没有扫描到，默认加密方式是WPA
                    if (Constants.wifiSsid != null && Constants.wifiSsid.equals(scanResult.SSID)) {
                        String encryption = scanResult.capabilities;
                        if (encryption != null) {
                            if (encryption.contains("WPA") || encryption.contains("wpa")) {
                                LogUtil.println(TAG + "judgeEncryption", " wap 方式加密");
                                Constants.wifiEncription = 3;
                                return;
                            } else if (encryption.contains("WEB") || encryption.contains("web")) {
                                LogUtil.println(TAG + "judgeEncryption", " web 方式加密");
                                Constants.wifiEncription = 2;
                                return;
                            }
                        } else {
                            LogUtil.println(TAG + "judgeEncryption", " 没有加密");
                            Constants.wifiEncription = 1;
                            return;
                        }
                    } else {
                        LogUtil.println(TAG + "judgeEncryption", "用户传来的wifi信息不存在或wifi列表中没有发现");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            } else {
                LogUtil.println(TAG + "judgeEncryption", " scanResult is null");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }

    }


    /**
     * 连接wifi
     */
    public void connectWifi() {
        if (!Constants.wifiSsid.equals("") && !Constants.userId.equals("")) {
            boolean isConnected = false;
            int connectTimes = 0;
            while (!isConnected && connectTimes < 10) {
                connectTimes++;
                isConnected = wifiUtil.connectWifi(Constants.wifiSsid, Constants.wifiPwd, Constants.wifiEncription);
                if (!isConnected) {
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }

            if (connectTimes >= 10) {
                LogUtil.println(TAG + "connectWifi", "wifi is unavailable");
                RestartAppUtil.restartApp(mContext, 0);
            }

        } else {
            LogUtil.println(TAG + "connectWifi", " 用户信息不完整！");
            RestartAppUtil.restartApp(mContext, 0);
        }
    }


}

以上代码是几乎WifiManager所有的方法，百度一搜几乎都能搜到，我做了一下整理，只不过比较全一些。
关键也就是这个类，你可以任意使用。

这个是监听wifi网络的三种方式，还是先上代码：

package com.everyoo.broadcast;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;

import com.everyoo.utils.LogUtil;
import com.everyoo.utils.WifiUtil;

/**
 * Android wifi状态三种广播
 * Created by yuanpeikai on 2016/10/9.
 */
public class NetworkReceiver extends BroadcastReceiver {
    private final String TAG = "NetworkReceiver ";

    @Override
    public void onReceive(Context context, Intent intent) {
        if (WifiManager.WIFI_STATE_CHANGED_ACTION.equals(intent.getAction())) {//这个监听wifi的打开与关闭，与wifi的连接无关
            int wifiState = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE, 0);
            switch (wifiState) {
                case WifiManager.WIFI_STATE_DISABLED:
                    LogUtil.println(TAG + "onReceive ", "wifi has been closed");
                    WifiUtil.getInstance(context).openWifi();
                    break;
                case WifiManager.WIFI_STATE_ENABLED:
                    LogUtil.println(TAG + "onReceive ", "wifi has been opened");
                    break;
            }
        } else if (WifiManager.NETWORK_STATE_CHANGED_ACTION.equals(intent.getAction())) { // 这个监听wifi的连接状态
                                                                                            // 这个监听wifi的连接状态即是否连上了一个有效无线路由，当上边广播的状态是WifiManager.WIFI_STATE_DISABLING，和WIFI_STATE_DISABLED的时候，根本不会接到这个广播。
                                                                                             // 在上边广播接到广播是WifiManager.WIFI_STATE_ENABLED状态的同时也会接到这个广播，当然刚打开wifi肯定还没有连接到有效的无线
            NetworkInfo info = intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);
            if (info.getState().equals(NetworkInfo.State.DISCONNECTED)) {
                LogUtil.println(TAG + "onReceive ", "wifi has been disconnected");

            } else if (info.getState().equals(NetworkInfo.State.CONNECTED)) {
                WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
                WifiInfo wifiInfo = wifiManager.getConnectionInfo();
                LogUtil.println(TAG + "onReceive ", "wifi has been connected to" + wifiInfo.getSSID());
            }
            LogUtil.println(TAG + "onReceive", "info.getState = " + info.getState());
        } else if (ConnectivityManager.CONNECTIVITY_ACTION.equals(intent.getAction())) {//这个监听网络连接的设置，包括wifi和移动数据的打开和关闭。.
                                                                                          //最好用的还是这个监听。wifi如果打开，关闭，以及连接上可用的连接都会接到监听。见log
                                                                                            // 这个广播的最大弊端是比上边两个广播的反应要慢，如果只是要监听wifi，我觉得还是用上边两个配合比较合适
            // if (Constants.isBind) {
            ConnectivityManager manager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo networkInfo = manager.getActiveNetworkInfo();
            if (networkInfo != null) {
                if (networkInfo.isAvailable() && networkInfo.isConnected()) {
                    if (networkInfo.getType() == ConnectivityManager.TYPE_ETHERNET) {
                        System.out.println("NetworkReceiver ethernet network is connected");
                    } else if (networkInfo.getType() == ConnectivityManager.TYPE_WIFI) {
                        System.out.println("NetworkReceiver wifi network is connected");
                    }
                } else if (networkInfo.isConnectedOrConnecting()) {
                    System.out.println("NetworkReceiver network is connecting");
                } else {
                    System.out.println("NetworkReceiver network is unKnow");
                }
            } else {
                System.out.println("NetworkReceiver network is null");
            }
            // }

        }
    }
}

源码demon地址下载

注释说的都比较清楚了，我也不多说了。为防止忘记，先记下来了，有点乱，以后还会好好整理的。

da_caoyuan
关注
专栏目录
网络连接评分机制之再谈WIFI与数据切换过程（原）
阿杜的专栏
10-08 7537
前面几节介绍了网络评分机制的运行流程，下面我们再次通过案例来梳理一下评分机制在使用过程中的体现。         用户原本在用数据上网，但是如果到了一个有WIFI的环境，并连接上了WIFI，此时用户的手机将会自动断开数据网络，这是如何做到的呢？         当用户来到WIFI环境时，如果连上了某个WIFI，那么此时的WIFI状态机将会进入L2ConnectedState状态，然后会更新当前
android 监听wifi的连接状态,Android判断wifi状态 监听wifi连接
weixin_33321740的博客
05-26 2512
一、添加权限二、注册监听广播注册监听有两种方式1.AndroidMainfest.xml 中注册2.在代码中注册IntentFilter filter = new IntentFilter();filter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);filter.addAction(WifiManager.WIFI_STATE_CHAN...
android13使用WifiManager控制wifi开关不生效
最新发布
weixin_36948927的博客
08-10 105
Android 13 使用 WifiManager 控制 WiFi 开关不生效 在 Android 开发中，WiFi的控制一直是开发者需要频繁接触的功能之一。在 Android 13 版本中，通过 WifiManager 控制 WiFi 的开关却面临一些新的挑战和限制。在这篇文章中，我们将探讨这个问题，并提供一些代码示例，...
WiFi接入原理
热门推荐
时有限
05-08 2万+
WiFi接入原理 工作站（STA，即无线客户端）首先需要通过主动/被动扫描发现周围的无线服务，再通过认证和关联两个过程后，才能和接入点（AP，Access Point）建立连接，最终接入无线局域网。 参考： Kelvel2012 DoubleLi Wayne-Woo Wayne-Woo Wayne-Woo 1. 扫描（Scanning） 无线客户端有两种方式可以获取到周围的无线...
WifiManager自动连接wifi接入点
Hknock的专栏
08-16 1万+
/** * * wifi管理类 * * */ public class WifiOperator { /** * wifiManager */ private WifiManager wm; /** * 上下文 */ private Context mContext; /**
android 判断wifi强弱,Android:通过WifiManager监听Wifi信号强弱
weixin_36318306的博客
05-26 1083
先来了解下Android如何获取wifi的信息：WifiManager wifi_service = (WifiManager)getSystemService(WIFI_SERVICE);WifiInfo wifiInfo = wifi_service.getConnectionInfo();其中WifiManager是管理wifi的最重要的类，详细请参考http://developer.and...
通过WifiManager监听Wifi信号强弱
11-04
在Android系统中，开发者可以利用`WifiManager`这个系统服务来获取和操作Wi-Fi相关的功能，包括监听Wi-Fi信号的强度。本篇文章将详细介绍如何通过`WifiManager`监听Wi-Fi信号强弱，并根据信号强度的变化来进行相应的...
Android WIFI开发：获取wifi列表，连接指定wifi，获取wifi加密方式，监听wifi网络变化等
wuqingsen1的博客
09-06 8583
下面是 Android 开发中 WiFi 的常用配置，如：获取当前 WiFi ，扫描 WiFi 获取列表，连接指定 WiFi ，监听网络变化等等。 下面是效果图： GitHub 下载地址：https://github.com/wuqingsen/WifiDemoWu csdn 下载地址 ：https://download.csdn.net/download/wuqingsen1/1...
wifimanager.java_android自动连接wifi——WifiManager
weixin_42350014的博客
02-27 612
WifiManager工具类：android包中自带有WifiManager工具类，专门用于wifi管理：importandroid.net.wifi.WifiManager;取得WifiManager对象：WifiManagermWifiManager=(WifiManager)context.getSystemService(Context.WIFI_SERVICE);打开WIFI：...
WifiUtils:轻松连接到WiFi网络
05-02
无线上网 WiFi Utils是一个库，提供了一组方便的方法来管理WiFi状态，WiFi扫描以及与热点的WiFi连接。 如果您曾经使用过WifiManager ，则应该知道进行简单的wifi网络扫描是多么痛苦，或者以编程方式连接到热点甚至更糟。 这就是我的新图书馆的全部内容。 为了使我（以及希望对其他开发人员）更轻松地执行Java代码中的此类任务。 因此，让我们跳入一些代码示例。 启用/禁用WiFi 使用以下方法打开设备的wifi： WifiUtils . withContext(getApplicationContext()) . enableWifi( this :: checkResult); 其中checkResult可能是您自己的自定义方法，将在每种情况下进行相应处理。 例如： private void checkResult( boolean isSuccess)
使用WiFIManager自动连接指定Wifi
Tianhui Yang的个人网站：aitech.me
05-06 905
定义连接方法的class open WiFi configure WiFi connet WiFi public class WifiAdmin { // 定义WifiManager对象 private WifiManager mWifiManager; // 定义WifiInfo对象 private WifiInfo mWifiInfo; public Wif
android自动连接到指定wifi
yhm2046的专栏
01-24 1万+
主类: public class WifiAdmin { // 定义WifiManager对象 private WifiManager mWifiManager; // 定义WifiInfo对象 private WifiInfo mWifiInfo; // 扫描出的网络连接列表,ScanResult主要用来描述已经检测出的接入点，包括介入点的地址，介入点的名称，身份认证，频率，信号强度
使用Android的WiFiManager管理WiFi状态
chuyouyinghe的专栏
10-18 863
通过使用Android的WiFiManager，我们可以轻松地管理设备的WiFi状态，包括打开/关闭WiFi、扫描可用网络和连接到指定网络。这为我们的移动体验增添了更多便利性。无论是在家中还是在外出，通过管理WiFi状态，我们能够更好地掌控我们的网络连接。希望这篇对你有所帮助！版权声明：本文为CSDN博主「晋级的程序员」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
Android 监听wifi广播的两种方式
an__qi的专栏
05-20 995
http://blog.csdn.net/h3c4lenovo/article/details/9627781 2013-07-30 14:35 1533人阅读 评论(0) 收藏 举报 1.XML中声明                                                                        
Android-WiFi开发之 WifiManager
qq_23174861的博客
05-24 2697
前言:在初始涉足Android系统开发时, 对于WiFi是一个门外汉; 逐渐开始接触做系统应用, 开始整理WiFi相关的知识点, 今天更新一下WiFi的管理类 ------&gt; WifiManager;一. 简介:WifiManager这个类, 是 Android 暴露给开发者使用的一个系统服务管理类, 其中包含对WiFi的响应的操作函数; 其隐藏掉的系统服务类为IWifiService, 为...
如何连接上AccessPoint，WifiManager.connect
yu_zongyao的专栏
02-02 1518
/** * Connect to a network with the given configuration. The network also * gets added to the supplicant configuration. * * For a new network, this function is used instead of...
android开发 监听wifi的连接状态的kotlin代码以及使用
05-30
可以使用以下 Kotlin 代码监听 WiFi 的连接状态： ```kotlin import android.content.BroadcastReceiver import android.content.Context import android.content.Intent import android.net.ConnectivityManager ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值