[英]Detect if Android device has Internet connection
我需要判斷我的設備是否有 Internet 連接。 我找到了很多答案,例如:
private boolean isNetworkAvailable() {
ConnectivityManager connectivityManager
= (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
return activeNetworkInfo != null;
}
(取自檢測 Android 上是否有可用的 Internet 連接。)
但這是不對的,例如,如果我連接到無法訪問 Internet 的無線網絡,此方法將返回 true...有沒有辦法判斷設備是否有 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;
}
如果 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);
}
您不一定需要建立完整的 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 類在后台檢查互聯網連接,然后使用結果調用偵聽器方法。
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;
}
希望以上代碼對您有所幫助,同時確保您的應用程序具有互聯網權限。
文檔中的最新方法是使用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
}
使用以下類,更新到最后一個 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
之類的 FATAL EXCEPTIONs ,那么這個答案真的會對您有所幫助。
因為我在嘗試實現這一點時遇到了這個錯誤。
這個錯誤的原因是網絡相關的代碼不能在主線程上。
因此,您需要創建一個新線程,如下所示:
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
try {
//Your code goes here
} catch (Exception e) {
e.printStackTrace();
}
}});
並將您的代碼放在我評論的地方。
聲明:本站的技術帖子網頁,遵循CC BY-SA 4.0協議,如果您需要轉載,請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.