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

我不希望我的用户尝试下载任何东西，除非他们连接了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作为状态。

251918 次浏览
小开
最佳答案

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

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为这个工作。

注2: public NetworkInfo getNetworkInfo (int networkType)现在已弃用:

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

NOTE3: public static final int TYPE_WIFI现在已弃用:

此常量在API级别28中已弃用。 应用程序应该使用networkcapabilities . hatransporsport (int)或requestNetwork(NetworkRequest, NetworkCallback)来请求一个合适的网络。

小开

我简单地使用以下方法:

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

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

ASSOCIATED -关联完成。

ASSOCIATING -尝试关联 访问点。

COMPLETED -所有认证 完成。< / p >

DISCONNECTED -该状态表示 该客户端没有关联，但已关联 可能要开始找入口了 点。< / p >

休眠- android添加的状态 当客户端发出 显式DISCONNECT命令。< / p >

FOUR_WAY_HANDSHAKE - WPA 4-Way Key 正在握手。< / p >

GROUP_HANDSHAKE - WPA组密钥 正在握手。< / p >

INACTIVE—未激活状态。

INVALID -应该的伪状态

扫描—网络扫描。

UNINITIALIZED -没有连接。

小开

我看了一些像这样的问题，然后想到了这个:

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

小开

我在我的应用程序中使用这个来检查活动网络是否为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


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

试试这个方法。

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

这种方法将有助于找到互联网连接是否可用。

小开

这对我来说很管用:

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

使用WifiManager你可以做到:

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

方法getNeworkId只有在没有连接到网络时才返回-1;

小开

下面是我在我的应用程序中使用的实用方法:

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();
}
小开
这是一个更简单的解决方案。参见Stack Overflow 检查Android上是否启用Wi-Fi问题。< / p >

注:不要忘记将代码添加到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>
小开

虽然杰森的回答是正确的，但现在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;
}
小开

由于方法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
}
}
小开

试一试

wifiManager.getConnectionInfo().getIpAddress()

这将返回0，直到设备有一个可用的连接(在我的机器上，三星SM-T280, Android 5.1.1)。

小开

你可以打开WIFI，如果它没有被激活如下 1. 查看@Jason Knight回复的WIFI状态 2. 如果没有激活，请激活它 不要忘记在manifest文件

中添加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();
}

｝

小开

在新版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
}
}


}
}

还要加上前提

小开

类似于@Jason Knight的回答，但以Kotlin的方式:

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


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

许多答案使用了废弃的代码，或者在更高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;
小开
以下代码(在Kotlin中)从API 21工作到至少当前的API版本(API 29)。 函数getWifiState()返回WiFi网络状态的3个可能值之一: 在枚举类中定义的Disable, EnabledNotConnected和Connected。 这允许做出更细粒度的决定，比如通知用户启用WiFi，或者如果已经启用，则连接到可用的网络之一。 但如果所需要的只是一个布尔值，指示WiFi接口是否连接到网络，那么另一个函数isWifiConnected()将为您提供该值。它使用前一个，并将结果与Connected.

它受到了之前一些答案的启发，但试图解决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()，和 类型中的内存泄漏，而不是来自任何其他派生上下文 调用进程。< / p >

在舱单中，不要忘记添加:

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

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

文档现在建议人们使用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;
}

记住也要在你的Manifest文件中添加权限ACCESS_NETWORK_STATE。

小开

添加到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" />
小开

这个问题有点老了，但我用的就是这个。要求最低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;
小开 
val wifi = context!!.applicationContext.getSystemService(Context.WIFI_SERVICE) as WifiManager?
if (wifi!!.isWifiEnabled)
//do action here
    

else
//do action here
小开

这适用于最新版本的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" />
小开

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

提交答案