检测安卓设备是否有互联网连接
我需要判断我的设备是否有 Internet 连接。我找到了很多答案，例如：
private boolean isNetworkAvailable() {
ConnectivityManager connectivityManager
= (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
return activeNetworkInfo != null;
}
（取自 Detect whether there is an Internet connection available on Android。）
但这是不对的，例如，如果我连接到无法访问 Internet 的无线网络，则此方法将返回 true... 有没有办法判断设备是否有 Internet 连接，而不是是否仅连接对某事？
isNetworkConnected 功能块包含不推荐用于所有 Build.VERSION.SDK_INT >= Build.VERSION_CODES.M 的代码。对此事进行更深入的讨论如何修复它可以在这里找到stackoverflow.com/questions/53532406/…
你说的对。您提供的代码仅检查是否存在网络连接。检查是否存在活动 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 在 this comment below 中指出的那样，请确保不要在主线程上运行此代码，否则您将收到 NetworkOnMainThread 异常（在 Android 3.0 或更高版本中）。请改用 AsyncTask 或 Runnable。
如果你想使用 google.com 你应该看看 Jeshurun 的修改。在 his answer 中，他修改了我的代码并提高了它的效率。如果您连接到
HttpURLConnection urlc = (HttpURLConnection)
(new URL("http://clients3.google.com/generate_204")
.openConnection());
然后检查 204 的响应代码
return (urlc.getResponseCode() == 204 && urlc.getContentLength() == 0);
那么您不必先获取整个谷歌主页。
我稍微修改了 THelper 的答案，使用 Android 已经使用的已知黑客来检查连接的 WiFi 网络是否可以访问互联网。这比抓取整个 Google 主页要高效得多。有关详细信息，请参阅 here 和 here。
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;
}
如果 Internet 实际可用，则返回 true，必须在后台线程上调用
确保你有这两个权限
<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
如果 http 由于新的 android 安全性而无法工作，他们现在不允许纯文本通信。现在只是绕过它。
android:usesCleartextTraffic="true"
我会建议你ping你自己的服务器。通过这种方式，您更有信心拥有互联网并且您的网络服务器也在工作。 （例如当您有互联网但您的服务器已关闭时）
如果您的目标是 Android 6.0 - Marshmallow（API 级别 23）或更高版本，则可以使用新的 NetworkCapabilities 类，即：
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);
}
connectivityManager.getActiveNetwork(); 需要 API lvl23，它是 Marshmallow 而不是 Lollipop。
capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) 似乎为我做了诀窍！
您不一定需要建立完整的 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);
AsyncTask 中使用
根据接受的答案，我用一个监听器构建了这个类，这样你就可以在主线程中使用它：
首先：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);
}
}
第二：在主线程中实例化一个类的实例并等待响应（如果您在这之前使用过 Firebase api for android 应该对您很熟悉！）。
new InternetCheck(activity).isInternetConnectionAvailable(new InternetCheck.InternetCheckListener() {
@Override
public void onComplete(boolean connected) {
//proceed!
}
});
现在在 onComplete 方法中，您将获得设备是否连接到互联网。
试试这个
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");
}
你可以用非常简单的类来做到这一点。
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 的 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
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;
}
希望以上代码对您有所帮助，同时确保您的应用程序具有互联网权限。
从 documentation 执行此操作的最新方法是使用 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;
}
您可以使用连接管理器。
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
}
使用 following class，更新到最后一个 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.os.NetworkOnMainThreadException这样的致命例外，那么这个答案真的会对您有所帮助。
因为我在尝试实现这个时遇到了这个错误。
这个错误的原因是网络相关的代码不能在主线程上。因此，您需要创建一个新线程，如下所示：
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
try {
//Your code goes here
} catch (Exception e) {
e.printStackTrace();
}
}});
并将您的代码放在我评论的地方。
ConnectivityManager不需要这样做）。否则，在 Android 4.x+ 设备上，您将收到NetworkOnMainThread异常。