如何查看 Android 上的 Wi-Fi 是否已连接？

Question

我什至不希望我的用户尝试下载某些内容，除非他们连接了 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 状态。

Answer 1

您应该能够使用 ConnectivityManager 来获取 Wi-Fi 适配器的状态。从那里您可以检查它是否已连接甚至可用。

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

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

注意：需要注意的是（对于我们这里的新手来说），您需要添加

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

到

AndroidManifest.xml 中才能使其正常工作。

注意2：公共网络信息getNetworkInfo (int networkType) 现已弃用：

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

注意3：公共静态最终int TYPE_WIFI现已弃用：

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

Answer 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
    }
}

Answer 3

我只是使用以下内容：

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

它将在您调用 getSupplicantState() 时返回这些状态之一；

关联 - 关联已完成。

关联 - 尝试与
一个接入点。

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

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

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

FOUR_WAY_HANDSHAKE - WPA 4 向密钥
握手正在进行中。

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

INACTIVE - 非活动状态。

INVALID - 伪状态应该
一般情况下是看不到的。

扫描 - 扫描网络。

未初始化 - 无连接。

Answer 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

}

Answer 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 进行许可证检查，它似乎工作得很好。

Answer 6

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

文档现在建议人们使用ConnectivityManager.NetworkCallback API 用于异步回调监控，或使用 ConnectivityManager#getNetworkCapability 或 ConnectivityManager#getLinkProperties< /code>用于同步访问网络信息

调用者应改用 ConnectivityManager.NetworkCallback API 来了解连接更改，或改用 ConnectivityManager#getNetworkCapability 或 ConnectivityManager#getLinkProperties 同步获取信息。

---

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

Kotlin:

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 到您的清单文件。

Answer 7

虽然 Jason 的答案是正确的，现在 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;
}

Answer 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;

Answer 9

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

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

wifiManager.connectionInfo.bssid != null 

而不是：

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

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

还要记住以下几点：

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

在清单中，不要忘记添加：

<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)
    }
}

Answer 10

这适用于 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
        }
}

Answer 11

使用 WifiManager 您可以执行以下操作：

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

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

Answer 12

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;
}

Answer 13

尝试一下这个方法。

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;
}

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

Answer 14

这对我有用：

    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" />

Answer 15

与 @Jason Knight 的答案类似，但采用 Kotlin 方式：

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

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

Answer 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();
}

Answer 17

在新版本的Android中

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
            }
        }

    }
}

也添加了权限

Answer 18

这是一个更简单的解决方案。请参阅堆栈溢出
问题检查 Android 上是否启用 Wi-Fi< /em>.

PS 不要忘记将代码添加到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>

Answer 19

Try

wifiManager.getConnectionInfo().getIpAddress()

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

Answer 20

如果没有开启WIFI，可以按如下方式打开WIFI
1. 检查 WIFI 状态（@Jason Knight 回答）
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();
}

}

Answer 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" />

Answer 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;

Answer 23

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

Answer 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" />