如何查看 Android 上是否连接了 Wi-Fi？答案

【问题标题】：How do I see if Wi-Fi is connected on Android?如何查看 Android 上是否连接了 Wi-Fi？
【发布时间】：2011-04-19 23:18:45
【问题描述】：

我不希望我的用户尝试下载某些东西，除非他们连接了 Wi-Fi。但是，我似乎只能判断是否启用了 Wi-Fi，但他们仍然可以连接 3G。

android.net.wifi.WifiManager m = (WifiManager) getSystemService(WIFI_SERVICE);
android.net.wifi.SupplicantState s = m.getConnectionInfo().getSupplicantState();
NetworkInfo.DetailedState state = WifiInfo.getDetailedStateOf(s);
if (state != NetworkInfo.DetailedState.CONNECTED) {
    return false;
}

但是，状态不是我所期望的。即使 Wi-Fi 已连接，我仍将OBTAINING_IPADDR 作为状态。

【问题讨论】：

2021 工作解决方案：stackoverflow.com/questions/66573565/…

标签： android android-wifi wifimanager

【解决方案1】：

您应该能够使用 ConnectivityManager 来获取 Wi-Fi 适配器的状态。从那里你可以check if it is connected or even available。

ConnectivityManager connManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo mWifi = connManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);

if (mWifi.isConnected()) {
    // Do whatever
}

注意：应该注意（对于我们这里的 n00bies）您需要添加

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

给你的

AndroidManifest.xml 才能正常工作。

NOTE2：public NetworkInfo getNetworkInfo (int networkType) 现已弃用：

此方法在 API 级别 23 中已弃用。此方法不支持多个相同类型的连接网络。采用 getAllNetworks() 和 getNetworkInfo(android.net.Network) 代替。

NOTE3：public static final int TYPE_WIFI 现已弃用：

此常量在 API 级别 28 中已弃用。应用程序应改为使用 NetworkCapabilities.hasTransport(int) 或 requestNetwork(NetworkRequest, NetworkCallback) 来请求适当的网络。支持的传输。

【讨论】：

应该注意（对于我们这里的菜鸟），您需要将 android.permission.ACCESS_NETWORK_STATE 添加到您的 AndroidManifest.xml 中才能正常工作。
在最新版本的 Android 中，您需要在 mWiFi 中检查 NULL ...您的代码可能会引发空指针错误。请参阅developer.android.com/training/basics/network-ops/managing.html，特别是“方法 getActiveNetworkInfo() 返回一个 NetworkInfo...”
它也适用于以太网接口。我刚改成 ConnectivityManager.TYPE_ETHERNET
方法 NetworkInfo.isConnected() 现在在 API-23 中已弃用。我在下面发布了一个解决方案。
NetworkInfo.getType() 和 ConnectivityManager.TYPE_WIFI 现在在 API 28 中已弃用。为避免 lint 警告，您应该使用类似 connectivityManager.getNetworkCapabilities(network).hasTransport(NetworkCapabilities.TRANSPORT_WIFI)

【解决方案2】：

由于方法 NetworkInfo.isConnected() 现在在 API-23 中不推荐使用，这里有一个方法可以检测 Wi- Fi 适配器已打开并且还使用 WifiManager 连接到接入点：

private boolean checkWifiOnAndConnected() {
    WifiManager wifiMgr = (WifiManager) getSystemService(Context.WIFI_SERVICE);

    if (wifiMgr.isWifiEnabled()) { // Wi-Fi adapter is ON

        WifiInfo wifiInfo = wifiMgr.getConnectionInfo();

        if( wifiInfo.getNetworkId() == -1 ){
            return false; // Not connected to an access point
        }
        return true; // Connected to an access point
    }
    else {
        return false; // Wi-Fi adapter is OFF
    }
}

【讨论】：

值得一提的是wifiInfo可以为null，所以我认为你应该在获取网络ID之前检查null
NetworkInfo.isConnected() 在我看来并没有被弃用。
别忘了添加权限：android.permission.ACCESS_WIFI_STATE
在没有定位权限和定位模式的情况下，这将不再在 Android Q 中工作，请参阅issuetracker.google.com/issues/136021574。
@EricRobertBrewer 评论不再是最新的。现在，API 29+ 已弃用。

【解决方案3】：

我只是使用以下内容：

SupplicantState supState; 
wifiManager = (WifiManager) getSystemService(Context.WIFI_SERVICE);
WifiInfo wifiInfo = wifiManager.getConnectionInfo();
supState = wifiInfo.getSupplicantState();

在您调用 getSupplicantState() 时将返回其中一种状态；

关联 - 关联完成。

ASSOCIATING - 试图与一个接入点。

已完成 - 所有身份验证完全的。

DISCONNECTED - 此状态表示该客户端没有关联，但可能会开始寻找访问权限观点。

DORMANT - Android 添加的状态当客户端发出显式 DISCONNECT 命令。

FOUR_WAY_HANDSHAKE - WPA 四向键正在进行握手。

GROUP_HANDSHAKE - WPA 组密钥正在进行握手。

INACTIVE - 非活动状态。

INVALID - 一个伪状态，应该通常永远不会被看到。

扫描 - 扫描网络。

未初始化 - 无连接。

【讨论】：

hi Donal。我用同样的方法来获取我们的设备是否连接到 wifi。但另外我需要知道当前使用 WIFI 的应用程序名称。如何做到这一点？
@AbhishekB，抱歉，我没有这方面的经验，或许可以尝试查看一些 Wi-Fi 监控应用程序，看看是否有可以查看代码的开源应用程序.
我对此解决方案持怀疑态度，因为仅在使用 WPA（或 WPA 的某些变体）时才使用请求者：如果用户连接到没有身份验证或 WEP 的 AP，则不涉及请求者.
即使我没有使用 wifi，它仍然显示为“已完成”
上述状态是否有系统广播意图？ @DonalRafferty

【解决方案4】：

我在我的应用程序中使用它来检查活动网络是否是 Wi-Fi：

ConnectivityManager cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo ni = cm.getActiveNetworkInfo();
if (ni != null && ni.getType() == ConnectivityManager.TYPE_WIFI)
{

    // Do your work here

}

【讨论】：

这是最好的答案，因为它确保active 网络（将用于下载的网络）是 WiFi
现在NetworkInfo#isConnected已弃用也是最好的答案
绝对是今年（2017 年）的最佳答案。
2020 年也是最佳解决方案，因为 Android Q 为本文中的一些解决方案请求位置权限。这无需位置权限即可工作。

【解决方案5】：

我看了几个这样的问题并想出了这个：

ConnectivityManager connManager = (ConnectivityManager) getSystemService(CONNECTIVITY_SERVICE);
NetworkInfo wifi = connManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
NetworkInfo mobile = connManager .getNetworkInfo(ConnectivityManager.TYPE_MOBILE);

if (wifi.isConnected()){
    // If Wi-Fi connected
}

if (mobile.isConnected()) {
    // If Internet connected
}

我在 Root Toolbox PRO 中使用 if 来检查我的许可证，它似乎工作得很好。

【讨论】：

看起来不错，但我不确定为什么您会再次引用 ConnectivityManager。在这个例子中 connManager 和 connManager1 都是同一个对象
TYPE_MOBLIE 是指 3gnet 还是 gprs 网？
TYPE_MOBILE 表示使用您的运营商的任何数据 - 2G (GPRS...)、3G (HSDPA...) 或 4G (LTE...)。
您可以添加 TYPE_ETHERNET，当将 android 连接到以太网时效果很好
值得注意的是，如果网络不存在，getNetworkInfo() 将返回 null。因此，如果设备没有移动连接，这将引发错误。在大多数情况下，TYPE_ETHERNET 在这种情况下会导致 null，因为大多数设备都没有以太网连接。

【解决方案6】：

虽然Jason's answer 是正确的，但现在 getNetWorkInfo (int) 是一种已弃用的方法。所以，下一个函数将是一个不错的选择：

public static boolean isWifiAvailable (Context context)
{
    boolean br = false;
    ConnectivityManager cm = null;
    NetworkInfo ni = null;

    cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    ni = cm.getActiveNetworkInfo();
    br = ((null != ni) && (ni.isConnected()) && (ni.getType() == ConnectivityManager.TYPE_WIFI));

    return br;
}

【讨论】：

【解决方案7】：

自 API 级别 29 起，NetworkInfo 类以及相关的访问方法（如 ConnectivityManager#getNetworkInfo() 和 ConnectivityManager#getActiveNetworkInfo()）已被弃用。

documentation 现在建议人们使用ConnectivityManager.NetworkCallback API 进行异步回调监控，或者使用ConnectivityManager#getNetworkCapabilities 或ConnectivityManager#getLinkProperties 来同步访问网络信息

调用者应改为使用 ConnectivityManager.NetworkCallback API 来了解连接更改，或切换到使用 ConnectivityManager#getNetworkCapabilities 或 ConnectivityManager#getLinkProperties 来同步获取信息。

要检查是否连接了 WiFi，这是我使用的代码：

科特林：

val connMgr = applicationContext.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager?
connMgr?: return false
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
    val network: Network = connMgr.activeNetwork ?: return false
    val capabilities = connMgr.getNetworkCapabilities(network)
    return capabilities != null && capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
} else {
    val networkInfo = connMgr.activeNetworkInfo ?: return false
    return networkInfo.isConnected && networkInfo.type == ConnectivityManager.TYPE_WIFI
}

Java：

ConnectivityManager connMgr = (ConnectivityManager) getApplicationContext().getSystemService(Context.CONNECTIVITY_SERVICE);
if (connMgr == null) {
    return false;
}
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
    Network network = connMgr.getActiveNetwork();
    if (network == null) return false;
    NetworkCapabilities capabilities = connMgr.getNetworkCapabilities(network);
    return capabilities != null && capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI);
} else {
    NetworkInfo networkInfo = connMgr.getActiveNetworkInfo();
    return networkInfo.isConnected() && networkInfo.getType() == ConnectivityManager.TYPE_WIFI;
}

记住还要将权限ACCESS_NETWORK_STATE 添加到您的清单文件中。

【讨论】：

【解决方案8】：

许多答案使用已弃用的代码，或更高 API 版本上可用的代码。现在我用这样的东西

ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        if(connectivityManager != null) {
            for (Network net : connectivityManager.getAllNetworks()) {
                NetworkCapabilities nc = connectivityManager.getNetworkCapabilities(net);
                if (nc != null && nc.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
                        && nc.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET))
                    return true;
            }
        }
        return false;

【讨论】：

【解决方案9】：

以下代码（在 Kotlin 中）从 API 21 开始工作，直到至少当前的 API 版本 (API 29)。函数 getWifiState() 返回 WiFi 网络状态的 3 个可能值之一：在枚举类中定义的 Disable、EnabledNotConnected 和 Connected。这允许采取更精细的决策，例如通知用户启用 WiFi，或者如果已经启用，则连接到可用网络之一。但是，如果只需要一个布尔值来指示 WiFi 接口是否已连接到网络，那么另一个函数 isWifiConnected() 将为您提供。它使用前一个并将结果与 Connected 进行比较。

它在之前的一些答案中受到启发，但试图解决由 Android API 的演变或 IP V6 的可用性缓慢增加所引入的问题。诀窍是使用：

wifiManager.connectionInfo.bssid != null

代替：

getIpAddress() == 0 仅对 IP V4 有效或
getNetworkId() == -1 现在需要另一个特殊权限（位置）

根据文档：https://developer.android.com/reference/kotlin/android/net/wifi/WifiInfo.html#getbssid 如果未连接到网络，它将返回 null。即使我们无权获取真实值，如果我们连接，它仍然会返回 null 以外的值。

还要记住以下几点：

在 android.os.Build.VERSION_CODES#N 之前的版本中，此对象只能从 Context#getApplicationContext() 获取，并且不来自任何其他派生上下文以避免内存泄漏调用进程。

在Manifest中，不要忘记添加：

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

建议的代码是：

class MyViewModel(application: Application) : AndroidViewModel(application) {

   // Get application context
    private val myAppContext: Context = getApplication<Application>().applicationContext

   // Define the different possible states for the WiFi Connection
    internal enum class WifiState {
        Disabled,               // WiFi is not enabled
        EnabledNotConnected,    // WiFi is enabled but we are not connected to any WiFi network
        Connected,              // Connected to a WiFi network
    }

    // Get the current state of the WiFi network
    private fun getWifiState() : WifiState {

        val wifiManager : WifiManager = myAppContext.applicationContext.getSystemService(Context.WIFI_SERVICE) as WifiManager

        return if (wifiManager.isWifiEnabled) {
                    if (wifiManager.connectionInfo.bssid != null)
                        WifiState.Connected
                    else
                        WifiState.EnabledNotConnected
               } else {
                    WifiState.Disabled
               }
    }

    // Returns true if we are connected to a WiFi network
    private fun isWiFiConnected() : Boolean {
        return (getWifiState() == WifiState.Connected)
    }
}

【讨论】：

【解决方案10】：

使用WifiManager 你可以做到：

WifiManager wifi = (WifiManager) getSystemService (Context.WIFI_SERVICE);
if (wifi.getConnectionInfo().getNetworkId() != -1) {/* connected */}

getNeworkId 方法仅在未连接到网络时返回 -1；

【讨论】：

WIFI_STATE_DISABLED 常量值：1 (0x00000001) WIFI_STATE_DISABLING 常量值：0 (0x00000000) WIFI_STATE_ENABLED 常量值：3 (0x00000003) WIFI_STATE_ENABLING 常量值：2 (0x00000002) WIFI_STATE_UN跨度>
developer.android.com/reference/android/net/wifi/…
在没有定位权限和定位模式的情况下，这将不再适用于 Android Q，请参阅issuetracker.google.com/issues/136021574。

【解决方案11】：

ConnectivityManager manager = (ConnectivityManager) getSystemService(CONNECTIVITY_SERVICE);
boolean is3g = manager.getNetworkInfo(
                  ConnectivityManager.TYPE_MOBILE).isConnectedOrConnecting();
boolean isWifi = manager.getNetworkInfo(
                    ConnectivityManager.TYPE_WIFI).isConnectedOrConnecting();

Log.v("", is3g + " ConnectivityManager Test " + isWifi);
if (!is3g && !isWifi) {
    Toast.makeText(
        getApplicationContext(),
        "Please make sure, your network connection is ON ",
        Toast.LENGTH_LONG).show();
}
else {
    // Put your function() to go further;
}

【讨论】：

添加一些解释而不是代码会更好。
我会使用 isConnected()，文档说：boolean isConnectedOrConnecting () 表示网络连接是否存在或正在建立过程中。这对于需要执行与网络相关的任何操作（而不是读取或写入数据）的应用程序很有用。对于后者，请改为调用isConnected()，这样可以保证网络完全可用。

【解决方案12】：

试试这个方法。

public boolean isInternetConnected() {
    ConnectivityManager conMgr = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
    boolean ret = true;
    if (conMgr != null) {
        NetworkInfo i = conMgr.getActiveNetworkInfo();

        if (i != null) {
            if (!i.isConnected()) {
                ret = false;
            }

            if (!i.isAvailable()) {
                ret = false;
            }
        }

        if (i == null)
            ret = false;
    } else
        ret = false;
    return ret;
}

此方法将有助于查找可用或不可用的互联网连接。

【讨论】：

我正在寻找活动连接是否是 wifi。此外，无需对 conMgr 进行空检查，它永远不会为空。
你能检查一下this question吗？ :(

【解决方案13】：

这对我有用：

    ConnectivityManager conMan = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);

    // Mobile
    State mobile = conMan.getNetworkInfo(ConnectivityManager.TYPE_MOBILE).getState();

    // Wi-Fi
    State wifi = conMan.getNetworkInfo(ConnectivityManager.TYPE_WIFI).getState();

    // And then use it like this:

    if (mobile == NetworkInfo.State.CONNECTED || mobile == NetworkInfo.State.CONNECTING)
    {
        Toast.makeText(Wifi_Gprs.this,"Mobile is Enabled :) ....",Toast.LENGTH_LONG).show();
    }
    else if (wifi == NetworkInfo.State.CONNECTED || wifi == NetworkInfo.State.CONNECTING)
    {
        Toast.makeText(Wifi_Gprs.this,"Wifi is Enabled  :) ....",Toast.LENGTH_LONG).show();
    }
    else
    {
        Toast.makeText(Wifi_Gprs.this,"No Wifi or Gprs Enabled :( ....",Toast.LENGTH_LONG).show();
    }

并添加此权限：

<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

【讨论】：

【解决方案14】：

类似于@Jason Knight 的回答，但采用 Kotlin 方式：

val connManager = getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
val mWifi = connManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI)

if (mWifi.isConnected) {
     // Do whatever
}

【讨论】：

ConnectivityManager.TYPE_WIFI 已弃用

【解决方案15】：

这适用于 Q 之前和之后的 Android 设备

fun isWifiConnected(context: Context):Boolean {
    val cm = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
             val capabilities = cm.getNetworkCapabilities(cm.activeNetwork)
             capabilities?.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)==true
        } else {
            val activeNetwork: NetworkInfo? = cm.activeNetworkInfo
            activeNetwork?.typeName?.contains("wifi",ignoreCase = true)?:false
        }
}

【讨论】：

【解决方案16】：

这是我在应用中用作实用方法的方法：

public static boolean isDeviceOnWifi(final Context context) {
        ConnectivityManager connManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo mWifi = connManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
        return mWifi != null && mWifi.isConnectedOrConnecting();
}

【讨论】：

在检查建立连接时，isConnectedOrConnecting 方法很重要。 IsConnected 方法对我不起作用。

【解决方案17】：

在新版本的安卓中

private void getWifiInfo(Context context) {
    ConnectivityManager connManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    Network[] networks = connManager.getAllNetworks();

    if(networks == null || networks.length == 0)
        return;

    for( int i = 0; i < networks.length; i++) {
        Network ntk = networks[i];
        NetworkInfo ntkInfo = connManager.getNetworkInfo(ntk);
        if (ntkInfo.getType() == ConnectivityManager.TYPE_WIFI && ntkInfo.isConnected() ) {
            final WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
            final WifiInfo connectionInfo = wifiManager.getConnectionInfo();
            if (connectionInfo != null) {
                // add some code here
            }
        }

    }
}

并添加权限

【讨论】：

connManager.getAllNetworks() 需要 API 级别 21。

【解决方案18】：

这是一个更简单的解决方案。见堆栈溢出问题Checking Wi-Fi enabled or not on Android。

附：不要忘记将代码添加到 manifest.xml 文件以允许权限。如下图。

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

【讨论】：

【解决方案19】：

试试

wifiManager.getConnectionInfo().getIpAddress()

这将返回 0，直到设备具有可用连接（在我的机器上，三星 SM-T280，Android 5.1.1）。

【讨论】：

【解决方案20】：

WIFI没有激活可以打开如下 1.检查@Jason Knight回答的WIFI状态 2.如果没有激活，激活它不要忘记在清单文件中添加WIFI权限

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

你的 Java 类应该是这样的

public class TestApp extends Activity {
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);

    //check WIFI activation
    ConnectivityManager connManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo mWifi = connManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);

    if (mWifi.isConnected() == false) {
        showWIFIDisabledAlertToUser();
    }
    else {
        Toast.makeText(this, "WIFI is Enabled in your devide", Toast.LENGTH_SHORT).show();
    }
}


private void showWIFIDisabledAlertToUser(){
    AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(this);
    alertDialogBuilder.setMessage("WIFI is disabled in your device. Would you like to enable it?")
            .setCancelable(false)
            .setPositiveButton("Goto Settings Page To Enable WIFI",
                    new DialogInterface.OnClickListener(){
                        public void onClick(DialogInterface dialog, int id){
                            Intent callGPSSettingIntent = new Intent(
                                    Settings.ACTION_WIFI_SETTINGS);
                            startActivity(callGPSSettingIntent);
                        }
                    });
    alertDialogBuilder.setNegativeButton("Cancel",
            new DialogInterface.OnClickListener(){
                public void onClick(DialogInterface dialog, int id){
                    dialog.cancel();
                }
            });
    AlertDialog alert = alertDialogBuilder.create();
    alert.show();
}

}

【讨论】：

【解决方案21】：

为 JAVA 添加这个：

public boolean CheckWifiConnection() {
        ConnectivityManager conMgr = (ConnectivityManager) getSystemService (Context.CONNECTIVITY_SERVICE);
        if (conMgr.getActiveNetworkInfo() != null
                && conMgr.getActiveNetworkInfo().isAvailable()
                && conMgr.getActiveNetworkInfo().isConnected()) {
            return true;
        } else {
            return false;
        }
    }

在 Manifest 文件中添加以下权限：

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

【讨论】：

【解决方案22】：

有点老问题，但这是我使用的。要求最低 api 级别 21 还考虑了已弃用的 Networkinfo api。

boolean isWifiConn = false;
    ConnectivityManager connMgr = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        Network network = connMgr.getActiveNetwork();
        if (network == null) return false;
        NetworkCapabilities capabilities = connMgr.getNetworkCapabilities(network);
        if(capabilities != null && capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)){
            isWifiConn = true;
            Toast.makeText(context,"Wifi connected Api >= "+Build.VERSION_CODES.M,Toast.LENGTH_LONG).show();
        }else{
            Toast.makeText(context,"Wifi not connected Api >= "+Build.VERSION_CODES.M,Toast.LENGTH_LONG).show();
        }
    } else {
        for (Network network : connMgr.getAllNetworks()) {
            NetworkInfo networkInfo = connMgr.getNetworkInfo(network);
            if (networkInfo.getType() == ConnectivityManager.TYPE_WIFI && networkInfo.isConnected()) {
                isWifiConn = true;
                Toast.makeText(context,"Wifi connected ",Toast.LENGTH_LONG).show();
                break;
            }else{
                Toast.makeText(context,"Wifi not connected ",Toast.LENGTH_LONG).show();
            }
        }
    }
    return isWifiConn;

【讨论】：

【解决方案23】：

val wifi = context!!.applicationContext.getSystemService(Context.WIFI_SERVICE) as WifiManager?        
         if (wifi!!.isWifiEnabled) 
              //do action here
    
         else 
             //do action here

【讨论】：

【解决方案24】：

这适用于最新版本的android：

fun getConnectionType(context: Context): ConnectivityType {
    var result = NONE
    val cm = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager?
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        if (cm != null) {
            val capabilities = cm.getNetworkCapabilities(cm.activeNetwork)
            if (capabilities != null) {
                when {
                    capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) -> {
                        result = WIFI
                    }
                    capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) -> {
                        result = MOBILE_DATA
                    }
                    capabilities.hasTransport(NetworkCapabilities.TRANSPORT_VPN) -> {
                        result = VPN
                    }
                }
            }
        }
    } else {
        if (cm != null) {
            val activeNetwork = cm.activeNetworkInfo
            if (activeNetwork != null) {
                // connected to the internet
                when (activeNetwork.type) {
                    ConnectivityManager.TYPE_WIFI -> {
                        result = WIFI
                    }
                    ConnectivityManager.TYPE_MOBILE -> {
                        result = MOBILE_DATA
                    }
                    ConnectivityManager.TYPE_VPN -> {
                        result = VPN
                    }
                }
            }
        }
    }
    return result
}

enum class ConnectivityType {
    NONE,
    MOBILE_DATA,
    WIFI,
    VPN,
}

在清单中：

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

【讨论】：