检测 Android 设备是否有 Internet 连接

小开

最佳答案

您是对的。您提供的代码只检查是否有网络连接。检查是否有活动的 Internet 连接的最佳方法是尝试连接通过 http 连接到一个已知的服务器。

public static boolean hasActiveInternetConnection(Context context) {
if (isNetworkAvailable(context)) {
try {
HttpURLConnection urlc = (HttpURLConnection) (new URL("http://www.google.com").openConnection());
urlc.setRequestProperty("User-Agent", "Test");
urlc.setRequestProperty("Connection", "close");
urlc.setConnectTimeout(1500);
urlc.connect();
return (urlc.getResponseCode() == 200);
} catch (IOException e) {
Log.e(LOG_TAG, "Error checking internet connection", e);
}
} else {
Log.d(LOG_TAG, "No network available!");
}
return false;
}

当然，您可以将 http://www.google.com URL 替换为您想要连接到的任何其他服务器，或者您知道具有良好正常运行时间的服务器。

正如 Tony Cho 在下面的评论中指出的，确保不要在主线程上运行这段代码，否则会出现 NetworkOnMainThread 异常(在 Android 3.0或更高版本中)。改为使用 AsyncTask 或 Runnable。

如果你想使用 google.com，你应该看看 Jeshurun 的修改。在他的回答中，他修改了我的代码，使之更加高效。如果你连接到

HttpURLConnection urlc = (HttpURLConnection)
(new URL("http://clients3.google.com/generate_204")
.openConnection());

然后检查响应码204

return (urlc.getResponseCode() == 204 && urlc.getContentLength() == 0);

那么你就不必首先获取整个谷歌主页。

小开

我稍微修改了一下 THelper 的回答，使用一个已知的黑客技术，Android 已经使用这个技术来检查已连接的 WiFi 网络是否可以访问互联网。这比搜索整个 Google 主页要有效得多。有关更多信息，请参见给你和给你。

public static boolean hasInternetAccess(Context context) {
if (isNetworkAvailable(context)) {
try {
HttpURLConnection urlc = (HttpURLConnection)
(new URL("http://clients3.google.com/generate_204")
.openConnection());
urlc.setRequestProperty("User-Agent", "Android");
urlc.setRequestProperty("Connection", "close");
urlc.setConnectTimeout(1500);
urlc.connect();
return (urlc.getResponseCode() == 204 &&
urlc.getContentLength() == 0);
} catch (IOException e) {
Log.e(TAG, "Error checking internet connection", e);
}
} else {
Log.d(TAG, "No network available!");
}
return false;
}

小开

public boolean isInternetWorking() {
boolean success = false;
try {
URL url = new URL("https://google.com");
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setConnectTimeout(10000);
connection.connect();
success = connection.getResponseCode() == 200;
} catch (IOException e) {
e.printStackTrace();
}
return success;
}

返回真，如果互联网实际上是可用的，必须在后台线程调用

确保你有这两个人的许可

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

如果 http 不工作，因为新的安卓系统的安全性，他们不允许纯文本通信现在。现在只是为了通过它。

Android: usesCleartextTraffic = “ true”

我建议您对自己的服务器进行 ping。通过这种方式，你更有信心，你有互联网，你的网络服务器也正在工作。(例如你有互联网，但是你的服务器坏了)

小开

试试这个

public class ConnectionDetector {
private Context _context;


public ConnectionDetector(Context context) {
this._context = context;
}


public boolean isConnectingToInternet() {
if (networkConnectivity()) {
try {
HttpURLConnection urlc = (HttpURLConnection) (new URL(
"http://www.google.com").openConnection());
urlc.setRequestProperty("User-Agent", "Test");
urlc.setRequestProperty("Connection", "close");
urlc.setConnectTimeout(3000);
urlc.setReadTimeout(4000);
urlc.connect();
// networkcode2 = urlc.getResponseCode();
return (urlc.getResponseCode() == 200);
} catch (IOException e) {
return (false);
}
} else
return false;


}


private boolean networkConnectivity() {
ConnectivityManager cm = (ConnectivityManager) _context
.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo networkInfo = cm.getActiveNetworkInfo();
if (networkInfo != null && networkInfo.isConnected()) {
return true;
}
return false;
}
}

您必须将以下权限添加到您的清单文件:

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

然后像这样打电话:

if((new ConnectionDetector(MyService.this)).isConnectingToInternet()){
Log.d("internet status","Internet Access");
}else{
Log.d("internet status","no Internet Access");
}

小开

如果你的目标是 Android 6.0-棉花糖(API 级别为23)或更高版本，可以使用新的 NetworkCapability 类，例如:

public static boolean hasInternetConnection(final Context context) {
final ConnectivityManager connectivityManager = (ConnectivityManager)context.
getSystemService(Context.CONNECTIVITY_SERVICE);


final Network network = connectivityManager.getActiveNetwork();
final NetworkCapabilities capabilities = connectivityManager
.getNetworkCapabilities(network);


return capabilities != null
&& capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED);
}

小开

您不一定需要建立完整的 HTTP 连接。您可以尝试只打开一个 TCP 连接到一个已知的主机，如果成功，您有互联网连接。

public boolean hostAvailable(String host, int port) {
try (Socket socket = new Socket()) {
socket.connect(new InetSocketAddress(host, port), 2000);
return true;
} catch (IOException e) {
// Either we have a timeout or unreachable host or failed DNS lookup
System.out.println(e);
return false;
}
}

那就去问问:

boolean online = hostAvailable("www.google.com", 80);

小开

基于已接受的答案，我用一个侦听器构建了这个类，这样你就可以在主线程中使用它:

首先 : InterntCheck 类，它在后台检查 Internet 连接，然后用结果调用侦听器方法。

public class InternetCheck extends AsyncTask<Void, Void, Void> {




private Activity activity;
private InternetCheckListener listener;


public InternetCheck(Activity x){


activity= x;


}


@Override
protected Void doInBackground(Void... params) {




boolean b = hasInternetAccess();
listener.onComplete(b);


return null;
}




public void isInternetConnectionAvailable(InternetCheckListener x){
listener=x;
execute();
}


private boolean isNetworkAvailable() {
ConnectivityManager connectivityManager = (ConnectivityManager) activity.getSystemService(CONNECTIVITY_SERVICE);
NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
return activeNetworkInfo != null;
}
private boolean hasInternetAccess() {
if (isNetworkAvailable()) {
try {
HttpURLConnection urlc = (HttpURLConnection) (new URL("http://clients3.google.com/generate_204").openConnection());
urlc.setRequestProperty("User-Agent", "Android");
urlc.setRequestProperty("Connection", "close");
urlc.setConnectTimeout(1500);
urlc.connect();
return (urlc.getResponseCode() == 204 &&
urlc.getContentLength() == 0);
} catch (IOException e) {
e.printStackTrace();
}
} else {
Log.d("TAG", "No network available!");
}
return false;
}


public interface InternetCheckListener{
void onComplete(boolean connected);
}


}

第二个 : 在主线程中实例化类的一个实例并等待响应(如果您在熟悉这个应用程序之前已经使用过针对 android 的 Firebase api).

new InternetCheck(activity).isInternetConnectionAvailable(new InternetCheck.InternetCheckListener() {


@Override
public void onComplete(boolean connected) {
//proceed!
}
});

现在在 onComplete 方法中，您将获得设备是否连接到因特网。

小开

private static NetworkUtil mInstance;
private volatile boolean mIsOnline;


private NetworkUtil() {
ScheduledExecutorService exec = Executors.newSingleThreadScheduledExecutor();
exec.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
boolean reachable = false;
try {
Process process = java.lang.Runtime.getRuntime().exec("ping -c 1 www.google.com");
int returnVal = process.waitFor();
reachable = (returnVal==0);
} catch (Exception e) {
e.printStackTrace();
}
mIsOnline = reachable;
}
}, 0, 5, TimeUnit.SECONDS);
}


public static NetworkUtil getInstance() {
if (mInstance == null) {
synchronized (NetworkUtil.class) {
if (mInstance == null) {
mInstance = new NetworkUtil();
}
}
}
return mInstance;
}


public boolean isOnline() {
return mIsOnline;
}

希望以上代码可以帮助您，也请确保您在您的应用程序中有互联网权限。

小开

从文件中实现这一点的最新方法是使用 ConnectivityManager查询活动网络，并确定它是否具有 Internet 连接。

public boolean hasInternetConnectivity() {
ConnectivityManager cm =
(ConnectivityManager)context.getSystemService(Context.CONNECTIVITY_SERVICE);


NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
return (activeNetwork != null &&
activeNetwork.isConnectedOrConnecting());
}

将这两个权限添加到 AndroidManifest.xml 文件:

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

小开

在连接管理器中检查 wifi 类型:

   //check network connection
ConnectivityManager cm = (ConnectivityManager) this.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
boolean hasNetworkConnection = activeNetwork != null && activeNetwork.isConnectedOrConnecting();
System.out.println("Connection ? : " + hasNetworkConnection);
//check wifi
boolean hasWifiConnection = activeNetwork.getType() == ConnectivityManager.TYPE_WIFI;
System.out.println("Wifi ? : " + hasWifiConnection);

Android 文档将“ TYPE _ WIFI”描述为“ WIFI 数据连接。设备可能支持多个连接。”

小开

一个检查活动网络是否有互联网连接的很好的解决方案:

public boolean isNetworkAvailable(Context context) {
ConnectivityManager connectivityManager
= (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
if (connectivityManager != null) {
Network network = connectivityManager.getActiveNetwork();
NetworkCapabilities networkCapabilities = connectivityManager.getNetworkCapabilities(network);
return networkCapabilities != null && networkCapabilities
.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET);
}
return false;
}

小开

您可以使用 ConnectivityManager。

val cm = getApplicationContext().getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
val activeNetwork: NetworkInfo? = cm.activeNetworkInfo
val dialogBuilder = AlertDialog.Builder(this)


if (activeNetwork!=null) // Some network is available
{
if (activeNetwork.isConnected) { // Network is connected to internet


}else{ // Network is NOT connected to internet


}

检查这个和这个

小开

使用以下课程，更新到最后的 API 级别: 29。

// License: MIT
// http://opensource.org/licenses/MIT
package net.i2p.android.router.util;


import android.content.Context;
import android.net.ConnectivityManager;
import android.net.Network;
import android.net.NetworkCapabilities;
import android.net.NetworkInfo;
import android.os.AsyncTask;
import android.os.Build;
import android.telephony.TelephonyManager;


import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.concurrent.CancellationException;






/**
* Check device's network connectivity and speed.
*
* @author emil http://stackoverflow.com/users/220710/emil
* @author str4d
* @author rodrigo https://stackoverflow.com/users/5520417/rodrigo
*/
public class ConnectivityAndInternetAccessCheck {


private static ArrayList < String > hosts = new ArrayList < String > () {
{
add("google.com");
add("facebook.com");
add("apple.com");
add("amazon.com");
add("twitter.com");
add("linkedin.com");
add("microsoft.com");
}
};
/**
* Get the network info.
*
* @param context the Context.
* @return the active NetworkInfo.
*/
private static NetworkInfo getNetworkInfo(Context context) {
NetworkInfo networkInfo = null;
ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
if (cm != null) {
networkInfo = cm.getActiveNetworkInfo();
}
return networkInfo;
}


/**
* Gets the info of all networks
* @param context The context
* @return an array of @code\{\{@link NetworkInfo}}
*/
private static NetworkInfo[] getAllNetworkInfo(Context context) {
ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
return cm.getAllNetworkInfo();
}


/**
* Gives the connectivity manager
* @param context The context
* @return the @code\{\{@link ConnectivityManager}}
*/
private static ConnectivityManager getConnectivityManager(Context context) {
return (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
}


/**
* Check if there is any connectivity at all.
*
* @param context the Context.
* @return true if we are connected to a network, false otherwise.
*/
public static boolean isConnected(Context context) {
boolean isConnected = false;
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
ConnectivityManager connectivityManager = ConnectivityAndInternetAccessCheck.getConnectivityManager(context);
Network[] networks = connectivityManager.getAllNetworks();
networksloop: for (Network network: networks) {
if (network == null) {
isConnected = false;
} else {
NetworkCapabilities networkCapabilities = connectivityManager.getNetworkCapabilities(network);
if(networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)){
isConnected = true;
break networksloop;
}
else {
isConnected = false;
}
}
}


} else {
NetworkInfo[] networkInfos = ConnectivityAndInternetAccessCheck.getAllNetworkInfo(context);
networkinfosloop: for (NetworkInfo info: networkInfos) {
// Works on emulator and devices.
// Note the use of isAvailable() - without this, isConnected() can
// return true when Wifi is disabled.
// http://stackoverflow.com/a/2937915
isConnected = info != null && info.isAvailable() && info.isConnected();
if (isConnected) {
break networkinfosloop;
}
}


}
return isConnected;
}


/**
* Check if there is any connectivity to a Wifi network.
*
* @param context the Context.
* @return true if we are connected to a Wifi network, false otherwise.
*/
public static boolean isConnectedWifi(Context context) {
boolean isConnectedWifi = false;
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
ConnectivityManager connectivityManager = ConnectivityAndInternetAccessCheck.getConnectivityManager(context);
Network[] networks = connectivityManager.getAllNetworks();
networksloop: for (Network network: networks) {
if (network == null) {
isConnectedWifi = false;
} else {
NetworkCapabilities networkCapabilities = connectivityManager.getNetworkCapabilities(network);
if(networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)){
if (networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
isConnectedWifi = true;
break networksloop;
} else {
isConnectedWifi = false;
}
}
}


}




} else {
NetworkInfo[] networkInfos = ConnectivityAndInternetAccessCheck.getAllNetworkInfo(context);
networkinfosloop: for (NetworkInfo n: networkInfos) {
isConnectedWifi = n != null && n.isAvailable() && n.isConnected() && n.getType() == ConnectivityManager.TYPE_WIFI;
if (isConnectedWifi) {
break networkinfosloop;
}


}
}
return isConnectedWifi;
}


/**
* Check if there is any connectivity to a mobile network.
*
* @param context the Context.
* @return true if we are connected to a mobile network, false otherwise.
*/
public static boolean isConnectedMobile(Context context) {
boolean isConnectedMobile = false;
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
ConnectivityManager connectivityManager = ConnectivityAndInternetAccessCheck.getConnectivityManager(context);
Network[] allNetworks = connectivityManager.getAllNetworks();
networksloop: for (Network network: allNetworks) {
if (network == null) {
isConnectedMobile = false;
} else {
NetworkCapabilities networkCapabilities = connectivityManager.getNetworkCapabilities(network);
if(networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)){
if (networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
isConnectedMobile = true;
break networksloop;
} else {
isConnectedMobile = false;
}
}
}


}


} else {
NetworkInfo[] networkInfos = ConnectivityAndInternetAccessCheck.getAllNetworkInfo(context);
networkinfosloop: for (NetworkInfo networkInfo: networkInfos) {
isConnectedMobile = networkInfo != null && networkInfo.isAvailable() && networkInfo.isConnected() && networkInfo.getType() == ConnectivityManager.TYPE_MOBILE;
if (isConnectedMobile) {
break networkinfosloop;
}
}
}
return isConnectedMobile;
}


/**
* Check if there is fast connectivity.
*
* @param context the Context.
* @return true if we have "fast" connectivity, false otherwise.
*/
public static boolean isConnectedFast(Context context) {
boolean isConnectedFast = false;
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
NetworkInfo[] networkInfos = ConnectivityAndInternetAccessCheck.getAllNetworkInfo(context);
networkInfosloop:
for (NetworkInfo networkInfo: networkInfos) {
isConnectedFast = networkInfo != null && networkInfo.isAvailable() && networkInfo.isConnected() && isConnectionFast(networkInfo.getType(), networkInfo.getSubtype());
if (isConnectedFast) {
break networkInfosloop;
}
}
} else {
throw new UnsupportedOperationException();
}
return isConnectedFast;
}


/**
* Check if the connection is fast.
*
* @param type the network type.
* @param subType the network subtype.
* @return true if the provided type/subtype combination is classified as fast.
*/
private static boolean isConnectionFast(int type, int subType) {
if (type == ConnectivityManager.TYPE_WIFI) {
return true;
} else if (type == ConnectivityManager.TYPE_MOBILE) {
switch (subType) {
case TelephonyManager.NETWORK_TYPE_1xRTT:
return false; // ~ 50-100 kbps
case TelephonyManager.NETWORK_TYPE_CDMA:
return false; // ~ 14-64 kbps
case TelephonyManager.NETWORK_TYPE_EDGE:
return false; // ~ 50-100 kbps
case TelephonyManager.NETWORK_TYPE_EVDO_0:
return true; // ~ 400-1000 kbps
case TelephonyManager.NETWORK_TYPE_EVDO_A:
return true; // ~ 600-1400 kbps
case TelephonyManager.NETWORK_TYPE_GPRS:
return false; // ~ 100 kbps
case TelephonyManager.NETWORK_TYPE_HSDPA:
return true; // ~ 2-14 Mbps
case TelephonyManager.NETWORK_TYPE_HSPA:
return true; // ~ 700-1700 kbps
case TelephonyManager.NETWORK_TYPE_HSUPA:
return true; // ~ 1-23 Mbps
case TelephonyManager.NETWORK_TYPE_UMTS:
return true; // ~ 400-7000 kbps
/*
* Above API level 7, make sure to set android:targetSdkVersion
* to appropriate level to use these
*/
case TelephonyManager.NETWORK_TYPE_EHRPD: // API level 11
return true; // ~ 1-2 Mbps
case TelephonyManager.NETWORK_TYPE_EVDO_B: // API level 9
return true; // ~ 5 Mbps
case TelephonyManager.NETWORK_TYPE_HSPAP: // API level 13
return true; // ~ 10-20 Mbps
case TelephonyManager.NETWORK_TYPE_IDEN: // API level 8
return false; // ~25 kbps
case TelephonyManager.NETWORK_TYPE_LTE: // API level 11
return true; // ~ 10+ Mbps
// Unknown
case TelephonyManager.NETWORK_TYPE_UNKNOWN:
default:
return false;
}
} else {
return false;
}
}


public ArrayList < String > getHosts() {
return hosts;
}


public void setHosts(ArrayList < String > hosts) {
this.hosts = hosts;
}
//TODO Debug on devices
/**
* Checks that Internet is available by pinging DNS servers.
*/
private static class InternetConnectionCheckAsync extends AsyncTask < Void, Void, Boolean > {


private Context context;


/**
* Creates an instance of this class
* @param context The context
*/
public InternetConnectionCheckAsync(Context context) {
this.setContext(context);
}


/**
* Cancels the activity if the device is not connected to a network.
*/
@Override
protected void onPreExecute() {
if (!ConnectivityAndInternetAccessCheck.isConnected(getContext())) {
cancel(true);
}
}


/**
* Tells whether there is Internet access
* @param voids The list of arguments
* @return True if Internet can be accessed
*/
@Override
protected Boolean doInBackground(Void...voids) {
return isConnectedToInternet(getContext());
}


@Override
protected void onPostExecute(Boolean aBoolean) {
super.onPostExecute(aBoolean);
}


/**
* The context
*/
public Context getContext() {
return context;
}


public void setContext(Context context) {
this.context = context;
}
} //network calls shouldn't be called from main thread otherwise it will throw //NetworkOnMainThreadException


/**
* Tells whether Internet is reachable
* @return true if Internet is reachable, false otherwise
* @param context The context
*/
public static boolean isInternetReachable(Context context) {
try {
return new InternetConnectionCheckAsync(context).execute().get();
} catch (CancellationException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
return false;
}


/**
* Tells whether there is Internet connection
* @param context The context
* @return @code {true} if there is Internet connection
*/
private static boolean isConnectedToInternet(Context context) {
boolean isAvailable = false;
if (!ConnectivityAndInternetAccessCheck.isConnected(context)) {
isAvailable = false;
} else {
try {
foreachloop: for (String h: new ConnectivityAndInternetAccessCheck().getHosts()) {
if (isHostAvailable(h)) {
isAvailable = true;
break foreachloop;
}
}
}
catch (IOException e) {
e.printStackTrace();
}
}


return isAvailable;


}


/**
* Checks if the host is available
* @param hostName
* @return
* @throws IOException
*/
private static boolean isHostAvailable(String hostName) throws IOException {
try (Socket socket = new Socket()) {
int port = 80;
InetSocketAddress socketAddress = new InetSocketAddress(hostName, port);
socket.connect(socketAddress, 3000);


return true;
} catch (UnknownHostException unknownHost) {
return false;
}
}
}

小开

您可以使用针对 android 的 ConnectivityManager API 来完成这项工作。它允许你检查你是否连接到互联网和你连接到的互联网连接类型。基本上，是计量的还是未计量的。

检查互联网连接。

ConnectivityManager cm = (ConnectivityManager)context.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
boolean isConnected = activeNetwork != null && activeNetwork.isConnectedOrConnecting();

文档链接: https://developer.android.com/training/monitoring-device-state/connectivity-status-type

小开

您可以通过非常简单的类来实现这一点。

class CheckInternet {
fun isNetworkAvailable(context: Context): Boolean {
val connectivityManager =
context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager?
val activeNetworkInfo = connectivityManager!!.activeNetworkInfo
return activeNetworkInfo != null && activeNetworkInfo.isConnected
}
}

现在你可以在任何类中检查这个。

if (CheckInternet().isNetworkAvailable(this)) {
//connected with internet
}else{
//Not connected with internet
}

小开

如果以上所有的答案得到你致命的例外，如 android.os.NetworkOnMainThreadException，这个答案将真正帮助你。
因为我在实现它的时候得到了这个错误。 < br >

出现此错误的原因是与 Network 相关的代码不能在主线程上。因此，您需要创建一个新的 Thread，如下所示:

Thread thread = new Thread(new Runnable() {


@Override
public void run() {
try  {
//Your code goes here
} catch (Exception e) {
e.printStackTrace();
}
}});

然后把你的代码放在我注释的地方。