Saya mendapatkan AsyncTaskyang seharusnya memeriksa akses jaringan ke nama host. Tetapi doInBackground()tidak pernah habis waktu. Adakah yang punya petunjuk?

public class HostAvailabilityTask extends AsyncTask<String, Void, Boolean> {

    private Main main;

    public HostAvailabilityTask(Main main) {
        this.main = main;
    }

    protected Boolean doInBackground(String... params) {
        Main.Log("doInBackground() isHostAvailable():"+params[0]);

        try {
            return InetAddress.getByName(params[0]).isReachable(30); 
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return false;       
    }

    protected void onPostExecute(Boolean... result) {
        Main.Log("onPostExecute()");

        if(result[0] == false) {
            main.setContentView(R.layout.splash);
            return;
        }

        main.continueAfterHostCheck();
    }   
}

Koneksi jaringan / akses Internet

• isConnectedOrConnecting()(digunakan dalam sebagian besar jawaban) memeriksa koneksi jaringan apa pun
• Untuk mengetahui apakah ada di antara jaringan tersebut yang memiliki akses internet , gunakan salah satu dari yang berikut ini

A) Ping Server (mudah)

// ICMP 
public boolean isOnline() {
    Runtime runtime = Runtime.getRuntime();
    try {
        Process ipProcess = runtime.exec("/system/bin/ping -c 1 8.8.8.8");
        int     exitValue = ipProcess.waitFor();
        return (exitValue == 0);
    }
    catch (IOException e)          { e.printStackTrace(); }
    catch (InterruptedException e) { e.printStackTrace(); }

    return false;
}

+ bisa berjalan di utas utama

- tidak berfungsi pada beberapa perangkat lama (Galays S3, dll.), itu memblokir sementara jika tidak ada internet tersedia.

B) Hubungkan ke Socket di Internet (lanjutan)

// TCP/HTTP/DNS (depending on the port, 53=DNS, 80=HTTP, etc.)
public boolean isOnline() {
    try {
        int timeoutMs = 1500;
        Socket sock = new Socket();
        SocketAddress sockaddr = new InetSocketAddress("8.8.8.8", 53);

        sock.connect(sockaddr, timeoutMs);
        sock.close();

        return true;
    } catch (IOException e) { return false; }
}

+sangat cepat (bagaimanapun juga), bekerja pada semua perangkat, sangat dapat diandalkan

- tidak dapat berjalan di utas UI

Ini bekerja sangat andal, di setiap perangkat, dan sangat cepat. Perlu dijalankan dalam tugas yang terpisah (misalnya ScheduledExecutorServiceatau AsyncTask).

Kemungkinan Pertanyaan

• Apakah ini cukup cepat?

  Ya, sangat cepat ;-)

• Apakah tidak ada cara yang dapat diandalkan untuk memeriksa internet, selain menguji sesuatu di internet?

  Tidak sejauh yang saya tahu, tetapi beri tahu saya, dan saya akan mengedit jawaban saya.

• Bagaimana jika DNSnya down?

  Google DNS (mis. 8.8.8.8) Adalah DNS publik terbesar di dunia. Per 2013 melayani 130 miliar permintaan per hari. Katakan saja, aplikasi Anda mungkin tidak akan menjadi pembicaraan saat ini.

• Izin mana yang diperlukan?

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

  Hanya akses internet - kejutan ^^ (Btw apakah Anda pernah memikirkan, bagaimana beberapa metode yang disarankan di sini bahkan dapat memiliki lem jarak jauh tentang akses internet, tanpa izin ini?)

Ekstra: AsyncTaskContoh Satu Kali

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

    private Consumer mConsumer;
    public  interface Consumer { void accept(Boolean internet); }

    public  InternetCheck(Consumer consumer) { mConsumer = consumer; execute(); }

    @Override protected Boolean doInBackground(Void... voids) { try {
        Socket sock = new Socket();
        sock.connect(new InetSocketAddress("8.8.8.8", 53), 1500);
        sock.close();
        return true;
    } catch (IOException e) { return false; } }

    @Override protected void onPostExecute(Boolean internet) { mConsumer.accept(internet); }
}

///////////////////////////////////////////////////////////////////////////////////
// Usage

    new InternetCheck(internet -> { /* do something with boolean response */ });

Extra: RxJava/RxAndroidContoh Satu Kali (Kotlin)

fun hasInternetConnection(): Single<Boolean> {
  return Single.fromCallable {
    try {
      // Connect to Google DNS to check for connection
      val timeoutMs = 1500
      val socket = Socket()
      val socketAddress = InetSocketAddress("8.8.8.8", 53)

      socket.connect(socketAddress, timeoutMs)
      socket.close()

      true
    } catch (e: IOException) {
      false
    }
  }
  .subscribeOn(Schedulers.io())
  .observeOn(AndroidSchedulers.mainThread())
}

///////////////////////////////////////////////////////////////////////////////////
    // Usage

    hasInternetConnection().subscribe { hasInternet -> /* do something */}

Jika perangkat dalam mode pesawat (atau mungkin dalam situasi lain di mana tidak ada jaringan yang tersedia), cm.getActiveNetworkInfo()akan null, jadi Anda perlu menambahkan tanda nullcentang.

Dimodifikasi ( solusi Eddie ) di bawah:

public boolean isOnline() {
    ConnectivityManager cm =
        (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo netInfo = cm.getActiveNetworkInfo();
    return netInfo != null && netInfo.isConnectedOrConnecting();
}

Tambahkan juga izin berikut ke AndroidManifest.xml:

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

Satu titik kecil lainnya, jika Anda benar-benar membutuhkan koneksi jaringan pada titik waktu tertentu, maka mungkin lebih baik untuk menggunakannya netInfo.isConnected()daripada netInfo.isConnectedOrConnecting. Saya kira ini tergantung kasus penggunaan individu.

Tidak perlu rumit. Cara paling sederhana dan kerangka kerja adalah dengan menggunakan ACCESS_NETWORK_STATEizin dan hanya membuat metode yang terhubung

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

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

Anda juga dapat menggunakan requestRouteToHostjika Anda memiliki host dan tipe koneksi tertentu (wifi / ponsel) dalam pikiran.

Anda juga perlu:

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

di manifes Android Anda.

Untuk mulai getActiveNetworkInfo()bekerja, Anda perlu menambahkan yang berikut ke manifes.

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

Lihatlah kelas ConnectivityManager. Anda dapat menggunakan kelas ini untuk mendapatkan informasi tentang koneksi aktif pada host. http://developer.android.com/reference/android/net/ConnectivityManager.html

EDIT: Anda bisa menggunakan

Context.getSystemService(Context.CONNECTIVITY_SERVICE)
    .getNetworkInfo(ConnectivityManager.TYPE_MOBILE) 

atau

Context.getSystemService(Context.CONNECTIVITY_SERVICE)
    .getNetworkInfo(ConnectivityManager.TYPE_WIFI) 

dan parsing detailState enum objek NetworkInfo yang dikembalikan

EDIT EDIT: Untuk mengetahui apakah Anda dapat mengakses host, Anda dapat menggunakan

Context.getSystemService(Context.CONNECTIVITY_SERVICE)
    .requestRouteToHost(TYPE_WIFI, int hostAddress)

Jelas, saya menggunakan Context.getSystemService (Context.CONNECTIVITY_SERVICE) sebagai proxy untuk mengatakan

ConnectivityManager cm = Context.getSystemService(Context.CONNECTIVITY_SERVICE);
cm.yourMethodCallHere();

periksa kode ini ... itu berhasil untuk saya :)

public static void isNetworkAvailable(final Handler handler, final int timeout) {
    // ask fo message '0' (not connected) or '1' (connected) on 'handler'
    // the answer must be send before before within the 'timeout' (in milliseconds)

    new Thread() {
        private boolean responded = false;   
        @Override
        public void run() { 
            // set 'responded' to TRUE if is able to connect with google mobile (responds fast) 
            new Thread() {      
                @Override
                public void run() {
                    HttpGet requestForTest = new HttpGet("http://m.google.com");
                    try {
                        new DefaultHttpClient().execute(requestForTest); // can last...
                        responded = true;
                    } 
                    catch (Exception e) {
                    }
                } 
            }.start();

            try {
                int waited = 0;
                while(!responded && (waited < timeout)) {
                    sleep(100);
                    if(!responded ) { 
                        waited += 100;
                    }
                }
            } 
            catch(InterruptedException e) {} // do nothing 
            finally { 
                if (!responded) { handler.sendEmptyMessage(0); } 
                else { handler.sendEmptyMessage(1); }
            }
        }
    }.start();
}

Lalu, saya mendefinisikan pawang:

Handler h = new Handler() {
    @Override
    public void handleMessage(Message msg) {

        if (msg.what != 1) { // code if not connected

        } else { // code if connected

        }   
    }
};

... dan luncurkan tes:

isNetworkAvailable(h,2000); // get the answser within 2000 ms

Ditemukan di dan dimodifikasi (!) Dari tautan ini :

Dalam file manifes Anda, tambahkan setidaknya:

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

Anda mungkin sudah memiliki izin INTERNET jika Anda mengaksesnya. Maka fungsi boolean yang memungkinkan untuk menguji konektivitas adalah:

private boolean checkInternetConnection() {
    ConnectivityManager cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
    // test for connection
    if (cm.getActiveNetworkInfo() != null
            && cm.getActiveNetworkInfo().isAvailable()
            && cm.getActiveNetworkInfo().isConnected()) {
        return true;
    } else {
        Log.v(TAG, "Internet Connection Not Present");
        return false;
    }
}

Saya membuat kode ini, ini adalah yang paling sederhana dan itu hanya boolean. dengan bertanyaif(isOnline()){

Anda dapatkan jika ada koneksi dan jika itu dapat terhubung ke halaman kode status 200(koneksi stabil).

Pastikan untuk menambahkan yang benar INTERNETdan ACCESS_NETWORK_STATEizin.

public boolean isOnline() {
    ConnectivityManager cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo netInfo = cm.getActiveNetworkInfo();
    if (netInfo != null && netInfo.isConnected()) {
        try {
            URL url = new URL("http://www.google.com");
            HttpURLConnection urlc = (HttpURLConnection) url.openConnection();
            urlc.setConnectTimeout(3000);
            urlc.connect();
            if (urlc.getResponseCode() == 200) {
                return new Boolean(true);
            }
        } catch (MalformedURLException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    return false;
}

Ini berhasil bagi saya:

Untuk memverifikasi ketersediaan jaringan:

private Boolean isNetworkAvailable() {
ConnectivityManager connectivityManager 
      = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
return activeNetworkInfo != null && activeNetworkInfo.isConnectedOrConnecting();}

Untuk memverifikasi akses internet:

public Boolean isOnline() {
    try {
        Process p1 = java.lang.Runtime.getRuntime().exec("ping -c 1 www.google.com");
        int returnVal = p1.waitFor();
        boolean reachable = (returnVal==0);
        return reachable;
    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    return false;
}

Ada lebih dari satu cara

Pertama, cara terpendek tetapi tidak efisien

Izin Keadaan Jaringan hanya diperlukan

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

Maka metode ini,

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

        NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
        boolean isConnected = activeNetwork != null &&
                activeNetwork.isConnected();

        return isConnected;

    }

Seperti yang terlihat dalam jawaban ConnectivityManageradalah solusi, saya hanya menambahkannya dalam suatu metode. Ini adalah metode yang disederhanakan semua digunakan
ConnectivityManager mengembalikan true jika ada akses jaringan bukan akses Internet, berarti jika WiFi Anda terhubung ke router tetapi router tidak memiliki internet itu mengembalikan true, itu memeriksa ketersediaan koneksi

Kedua, cara yang efisien

Status Jaringan dan Izin Internet diperlukan

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

Lalu kelas ini,

 public class CheckInternetAsyncTask extends AsyncTask<Void, Integer, Boolean> {

        private Context context;

        public CheckInternetAsyncTask(Context context) {
            this.context = context;
        }

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

            ConnectivityManager cm =
                    (ConnectivityManager)context.getSystemService(Context.CONNECTIVITY_SERVICE);

            assert cm != null;
            NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
            boolean isConnected = activeNetwork != null &&
                    activeNetwork.isConnected();


            if (isConnected) {
                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();
                    if (urlc.getResponseCode() == 204 &&
                            urlc.getContentLength() == 0)
                        return true;

                } catch (IOException e) {
                    Log.e("TAG", "Error checking internet connection", e);
                    return false;
                }
            } else {
                Log.d("TAG", "No network available!");
                return false;
            }


            return null;
        }

        @Override
        protected void onPostExecute(Boolean result) {
            super.onPostExecute(result);
            Log.d("TAG", "result" + result);

            if(result){
                // do ur code
            }

        }


    }

Panggilan CheckInternetAsyncTask

new CheckInternetAsyncTask(getApplicationContext()).execute();

Beberapa Penjelasan: -

• Anda harus memeriksa Internet AsyncTask, jika tidak maka akan melempar android.os.NetworkOnMainThreadExceptiondalam beberapa kasus

• ConnectivityManager digunakan untuk memeriksa akses jaringan jika benar mengirim permintaan (Ping)

• Minta kirim ke http://clients3.google.com/generate_204, URL terkenal ini dikenal untuk mengembalikan halaman kosong dengan status HTTP 204 ini lebih cepat dan lebih efisien daripada http://www.google.com, baca ini . jika Anda memiliki situs web, lebih disukai untuk menempatkan situs web Anda daripada google, hanya jika Anda menggunakannya di dalam aplikasi

• Batas waktu dapat diubah kisaran (20 ms -> 2000 ms), 1500 ms umumnya digunakan

Dari semua yang saya lihat sejauh ini, jalan terpendek dan terbersih adalah:

public final static boolean isConnected( Context context )
{   
   final ConnectivityManager connectivityManager = 
         (ConnectivityManager) context.getSystemService( Context.CONNECTIVITY_SERVICE );  
   final NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();    
   return networkInfo != null && networkInfo.isConnected();
}

PS: Ini tidak ping host mana pun, hanya memeriksa status koneksi, jadi jika router Anda tidak memiliki koneksi internet dan perangkat Anda terhubung dengannya metode ini akan kembali benar meskipun Anda tidak memiliki internet.
Untuk tes yang sebenarnya, saya akan merekomendasikan untuk mengeksekusi permintaan HttpHead (mis. Ke www.google.com) dan memeriksa statusnya, jika 200 OK semuanya baik-baik saja dan perangkat Anda memiliki koneksi internet.

Inilah metode yang saya gunakan:

public boolean isNetworkAvailable(final Context context) {
    return ((ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE)).getActiveNetworkInfo() != null;
}

Bahkan lebih baik, periksa untuk memastikan "terhubung":

public boolean isNetworkAvailable(final Context context) {
    final ConnectivityManager connectivityManager = ((ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE));
    return connectivityManager.getActiveNetworkInfo() != null && connectivityManager.getActiveNetworkInfo().isConnected();
}

Inilah cara menggunakan metode ini:

if (isNetworkAvailable(context)) {
    // code here
} else {
    // code
}

Izin diperlukan:

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

https://stackoverflow.com/a/16124915/950427

Satu kasus penggunaan penting pada perangkat seluler untuk memastikan koneksi yang sebenarnya ada. Ini adalah masalah umum ketika pengguna seluler memasuki jaringan Wifi dengan "Captive Portal", di mana mereka harus masuk. Saya menggunakan fungsi pemblokiran ini di latar belakang untuk memastikan koneksi ada.

/*
 * Not Thread safe. Blocking thread. Returns true if it
 * can connect to URL, false and exception is logged.
 */
public boolean checkConnectionHttps(String url){
    boolean responded = false;
    HttpGet requestTest = new HttpGet(url);
    HttpParams params = new BasicHttpParams();
    HttpConnectionParams.setConnectionTimeout(params, 3000);
    HttpConnectionParams.setSoTimeout(params, 5000);
    DefaultHttpClient client = new DefaultHttpClient(params);
    try {
        client.execute(requestTest);
        responded = true;
    } catch (ClientProtocolException e) {
        Log.w(MainActivity.TAG,"Unable to connect to " + url + " " + e.toString());
    } catch (IOException e) {
        Log.w(MainActivity.TAG,"Unable to connect to " + url + " " + e.toString());
        e.printStackTrace();
    }
    return responded;
}

Anda dapat mengulangi semua koneksi jaringan dan memeriksa apakah ada setidaknya satu koneksi yang tersedia:

public boolean isConnected() {
    boolean connected = false;

    ConnectivityManager cm = 
        (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);

    if (cm != null) {
        NetworkInfo[] netInfo = cm.getAllNetworkInfo();

        for (NetworkInfo ni : netInfo) {
            if ((ni.getTypeName().equalsIgnoreCase("WIFI")
                    || ni.getTypeName().equalsIgnoreCase("MOBILE"))
                    && ni.isConnected() && ni.isAvailable()) {
                connected = true;
            }

        }
    }

    return connected;
}

Bagi saya itu bukan praktik yang baik untuk memeriksa status koneksi di kelas Activity, karena

ConnectivityManager cm =
    (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);

harus dipanggil di sana, atau Anda perlu menekan instance Activity (konteks) Anda ke kelas handler koneksi untuk dapat memeriksa status koneksi di sana Ketika tidak ada koneksi yang tersedia (wifi, jaringan) Saya menangkap pengecualian UnknownHostException :

JSONObject jObj = null;
Boolean responded = false;
HttpGet requestForTest = new HttpGet("http://myserver.com");
try {
    new DefaultHttpClient().execute(requestForTest);
    responded = true;
} catch (UnknownHostException e) {
    jObj = new JSONObject();
    try {
        jObj.put("answer_code", 1);
        jObj.put("answer_text", "No available connection");
    } catch (Exception e1) {}
    return jObj;
} catch (IOException e) {
    e.printStackTrace();
}

Dengan cara ini saya dapat menangani kasus ini bersama dengan kasus-kasus lain di kelas yang sama (server saya selalu merespon balik dengan string json)

Ini bekerja untuk saya. Cobalah.

public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
    try {
        URL url = new URL("http://stackoverflow.com/posts/11642475/edit" );
        //URL url = new URL("http://www.nofoundwebsite.com/" );
        executeReq(url);
        Toast.makeText(getApplicationContext(), "Webpage is available!", Toast.LENGTH_SHORT).show();
    }
    catch(Exception e) {
        Toast.makeText(getApplicationContext(), "oops! webpage is not available!", Toast.LENGTH_SHORT).show();
    }
}

private void executeReq(URL urlObject) throws IOException
{
    HttpURLConnection conn = null;
    conn = (HttpURLConnection) urlObject.openConnection();
    conn.setReadTimeout(30000);//milliseconds
    conn.setConnectTimeout(3500);//milliseconds
    conn.setRequestMethod("GET");
    conn.setDoInput(true);

    // Start connect
    conn.connect();
    InputStream response =conn.getInputStream();
    Log.d("Response:", response.toString());
}}

Metode ini memberi Anda opsi untuk metode yang sangat cepat (untuk umpan balik waktu nyata) atau metode yang lebih lambat (untuk satu kali pemeriksaan yang memerlukan keandalan)

public boolean isNetworkAvailable(bool SlowButMoreReliable) {
    bool Result = false; 
    try {
        if(SlowButMoreReliable){
            ConnectivityManager MyConnectivityManager = null;
            MyConnectivityManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);

            NetworkInfo MyNetworkInfo = null;
            MyNetworkInfo = MyConnectivityManager.getActiveNetworkInfo();

            Result = MyNetworkInfo != null && MyNetworkInfo.isConnected();

        } else
        {
            Runtime runtime = Runtime.getRuntime();
            Process ipProcess = runtime.exec("/system/bin/ping -c 1 8.8.8.8");

            int i = ipProcess.waitFor();

            Result = i== 0;

        }

    } catch(Exception ex)
    {
        //Common.Exception(ex); //This method is one you should have that displays exceptions in your log
    }
    return Result;
}

Saya menggunakan kode ini sebagai ganti InetAddress:

    try {

        URL url = new URL("http://"+params[0]);

        HttpURLConnection urlc = (HttpURLConnection) url.openConnection();
        urlc.setRequestProperty("User-Agent", "Android Application:"+Z.APP_VERSION);
        urlc.setRequestProperty("Connection", "close");
        urlc.setConnectTimeout(1000 * 30); // mTimeout is in seconds
        urlc.connect();
        if (urlc.getResponseCode() == 200) {
            Main.Log("getResponseCode == 200");
            return new Boolean(true);
        }
    } catch (MalformedURLException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

Tidak rumit untuk memeriksa status konektivitas jaringan / internet Android. Kelas di bawah ini DetectConnectionakan membantu Anda memeriksa status ini:

import android.content.Context;
import android.net.ConnectivityManager;

public class DetectConnection {
    public static boolean checkInternetConnection(Context context) {
        ConnectivityManager con_manager = (ConnectivityManager) context
                                .getSystemService(Context.CONNECTIVITY_SERVICE);

        if (con_manager.getActiveNetworkInfo() != null
            && con_manager.getActiveNetworkInfo().isAvailable()
            && con_manager.getActiveNetworkInfo().isConnected()) {
                return true;
        } else {
            return false;
        }
    }
}

Untuk lebih jelasnya kunjungi Cara Memeriksa Status Jaringan Android / Konektivitas Internet

Pendekatan terbaik:

public static boolean isOnline() {
    try {
    InetAddress.getByName("google.com").isReachable(3);

    return true;
    } catch (UnknownHostException e){
    return false;
    } catch (IOException e){
    return false;
    }
    }

Berikut ini adalah kode dari Utilskelas saya :

public static boolean isNetworkAvailable(Context context) {
        ConnectivityManager connectivityManager 
              = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
        return activeNetworkInfo != null && activeNetworkInfo.isConnected();
}

public class Network {

Context context;

public Network(Context context){
    this.context = context;
}

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

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

}

Anda dapat menggunakan metode ini untuk mendeteksi ketersediaan jaringan-

public static boolean isDeviceOnline(Context context) {
        boolean isConnectionAvail = false;
        try {
            ConnectivityManager cm = (ConnectivityManager) context
                    .getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo netInfo = cm.getActiveNetworkInfo();
            return netInfo.isConnected();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return isConnectionAvail;
    }

Saya telah menerapkan solusi yang disediakan oleh @Levit dan membuat fungsi yang tidak akan memanggil Permintaan Http tambahan.

Ini akan menyelesaikan kesalahan Unable to Resolve Host

public static boolean isInternetAvailable(Context context) {
    ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
    if (activeNetwork == null) return false;

    switch (activeNetwork.getType()) {
        case ConnectivityManager.TYPE_WIFI:
            if ((activeNetwork.getState() == NetworkInfo.State.CONNECTED ||
                    activeNetwork.getState() == NetworkInfo.State.CONNECTING) &&
                    isInternet())
                return true;
            break;
        case ConnectivityManager.TYPE_MOBILE:
            if ((activeNetwork.getState() == NetworkInfo.State.CONNECTED ||
                    activeNetwork.getState() == NetworkInfo.State.CONNECTING) &&
                    isInternet())
                return true;
            break;
        default:
            return false;
    }
    return false;
}

private static boolean isInternet() {

    Runtime runtime = Runtime.getRuntime();
    try {
        Process ipProcess = runtime.exec("/system/bin/ping -c 1 8.8.8.8");
        int exitValue = ipProcess.waitFor();
        Debug.i(exitValue + "");
        return (exitValue == 0);
    } catch (IOException | InterruptedException e) {
        e.printStackTrace();
    }

    return false;
}

Sebut saja seperti,

if (!isInternetAvailable(getActivity())) {
     //Show message
} else {
     //Perfoem the api request
}

Ini tercakup dalam dokumen Android http://developer.android.com/training/monitoring-device-state/connectivity-monitoring.html

Saya telah memeriksa semua jawaban dan saya menemukan jawaban saya sendiri yang pertama-tama memeriksa apakah Internet tersedia dan apakah Internet tersedia kemudian memeriksa apakah itu aktif atau tidak.

Saya telah memasukkan semua metode dan kelas yang diperlukan untuk memeriksa koneksi Internet aktif.

NetworkUtils.class

public class NetworkUtils {

    public static final int STATUS_CONNECTED = 0 ;

    public static boolean isInternetAvailable(Context ctx){
        ConnectivityManager cm = (ConnectivityManager)ctx.getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
        return activeNetwork != null && activeNetwork.isConnectedOrConnecting();
    }

    public static int isInternetActiveWithPing() {
        try {
            Runtime runtime = Runtime.getRuntime();
            Process process = runtime.exec("/system/bin/ping -c 1 8.8.8.8");
            int exitValue = process.waitFor();
            return exitValue;
        } catch (Exception ex) {
            return -1;
        }
    }

    public static boolean isInternetActiveWithInetAddress() {
        try {
            InetAddress inetAddress = InetAddress.getByName("www.google.com");
            return inetAddress != null && !inetAddress.toString().equals("");
        } catch (Exception ex) {
            return false;
        }
    }

    public static void displayInternetConnectionMessage(Context ctx){
        Toast.makeText(ctx, "Check Internet Connection", Toast.LENGTH_SHORT).show();
    }
}

Anda dapat memeriksa apakah Internet aktif menggunakan kode di bawah ini:

 private void checkInternetConnection() {
        if (NetworkUtils.isInternetAvailable(this)) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    if (NetworkUtils.isInternetActiveWithPing() == NetworkUtils.STATUS_CONNECTED) {
                        performNetworkingOperations();
                    } else {
                        if (NetworkUtils.isInternetActiveWithInetAddress()) {
                            performNetworkingOperations();
                        } else {
                            displayConnectionMessage();
                        }
                    }
                }
            }).start();

        } else {
            displayConnectionMessage();
        }
    }

    private void performNetworkingOperations() {
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                Toast.makeText(MainActivity.this, "Internet is Available", Toast.LENGTH_SHORT).show();
            }
        });
    }

    private void displayConnectionMessage() {
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                NetworkUtils.displayInternetConnectionMessage(MainActivity.this);
            }
        });
    }

Sangat penting untuk memeriksa apakah kita memiliki konektivitas dengan isAvailable () dan jika memungkinkan untuk membuat koneksi dengan isConnected ()

private static ConnectivityManager manager;

public static boolean isOnline(Context context) {
    ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();
    return networkInfo != null && networkInfo.isAvailable() && networkInfo.isConnected();
}

dan Anda dapat menghentikan jenis WiFi aktif jaringan :

public static boolean isConnectedWifi(Context context) {
    ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();
    return networkInfo != null && networkInfo.getType() == ConnectivityManager.TYPE_WIFI;
}

atau Móvil seluler :

public static boolean isConnectedMobile(Context context) {
    ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();
    return networkInfo != null && networkInfo.getType() == ConnectivityManager.TYPE_MOBILE;
}

jangan lupa izinnya:

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

Kotlin dan coroutine

Saya telah menempatkan fungsi dalam ViewModel, yang memiliki viewModelScope. Menggunakan diamatiLiveData saya menginformasikan aktivitas tentang koneksi.

ViewModel

 fun checkInternetConnection() {
        viewModelScope.launch {
            withContext(Dispatchers.IO) {
                try {
                    val timeoutMs = 3000
                    val socket = Socket()
                    val socketAddress = InetSocketAddress("8.8.8.8", 53)

                    socket.connect(socketAddress, timeoutMs)
                    socket.close()

                    withContext(Dispatchers.Main) {
                        _connection.value = true
                    }
                }
                catch(ex: IOException) {
                    withContext(Main) {
                        _connection.value = false
                    }
                }
            }
        }
    }

 private val _connection = MutableLiveData<Boolean>()
 val connection: LiveData<Boolean> = _connection

Aktivitas

 private fun checkInternetConnection() {
     viewModel.connection.observe(this) { hasInternet ->
         if(!hasInternet) {
             //hasn't connection
         }
         else {
            //has connection
         }
     }
  }

Cukup buat kelas berikut yang memeriksa koneksi internet:

public class ConnectionStatus {

    private Context _context;

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

    public boolean isConnectionAvailable() {
        ConnectivityManager connectivity = (ConnectivityManager) _context
                .getSystemService(Context.CONNECTIVITY_SERVICE);
        if (connectivity != null) {
            NetworkInfo[] info = connectivity.getAllNetworkInfo();
            if (info != null)
                for (int i = 0; i < info.length; i++)
                    if (info[i].getState() == NetworkInfo.State.CONNECTED) {
                        return true;
                    }
        }
        return false;
    }
}

Kelas ini hanya berisi metode yang mengembalikan nilai boolean dari status koneksi. Oleh karena itu, secara sederhana, jika metode ini menemukan koneksi yang valid ke Internet, nilai baliknya adalah true, sebaliknya falsejika tidak ada koneksi yang valid ditemukan.

Metode berikut di MainActivity kemudian memanggil hasil dari metode yang dijelaskan sebelumnya, dan meminta pengguna untuk bertindak sesuai:

public void addListenerOnWifiButton() {
        Button btnWifi = (Button)findViewById(R.id.btnWifi);

        iia = new ConnectionStatus(getApplicationContext());

        isConnected = iia.isConnectionAvailable();
        if (!isConnected) {
            btnWifi.setOnClickListener(new View.OnClickListener() {

                @Override
                public void onClick(View v) {
                    startActivity(new Intent(Settings.ACTION_WIFI_SETTINGS));
                    Toast.makeText(getBaseContext(), "Please connect to a hotspot",
                            Toast.LENGTH_SHORT).show();
                }
            });
        }
        else {
            btnWifi.setVisibility(4);
            warning.setText("This app may use your mobile data to update events and get their details.");
        }
    }

Dalam kode di atas, jika hasilnya salah, (karena itu tidak ada koneksi internet, pengguna dibawa ke panel wi-fi Android, di mana ia diminta untuk terhubung ke hotspot wi-fi.

Pembaruan 29/06/2015 Jika Anda menggunakan Xamarin.Android dan ingin memeriksa konektivitas, Anda dapat menggunakan paket Nuget yang akan memberi Anda fungsionalitas ini pada banyak platform. Kandidat yang baik ada di sini dan di sini . [Akhir Pembaruan]

Jawaban di atas cukup bagus, tetapi semuanya ada di Jawa, dan hampir semuanya memeriksa konektivitas. Dalam kasus saya, saya perlu memiliki konektivitas dengan jenis koneksi tertentu dan saya sedang mengembangkan Xamarin. Android. Selain itu, saya tidak memberikan referensi untuk konteks kegiatan saya di lapisan Perangkat Keras, saya menggunakan Konteks Aplikasi. Jadi, inilah solusi saya, kalau-kalau ada orang datang ke sini dengan persyaratan yang sama. Saya belum melakukan pengujian penuh, akan memperbarui jawaban setelah saya selesai dengan pengujian saya

using Android.App;
using Android.Content;
using Android.Net;

namespace Leopard.Mobile.Hal.Android
{
    public class AndroidNetworkHelper
    {
        public static AndroidNetworkStatus GetWifiConnectivityStatus()
        {
            return GetConnectivityStatus(ConnectivityType.Wifi);
        }

        public static AndroidNetworkStatus GetMobileConnectivityStatus()
        {
            return GetConnectivityStatus(ConnectivityType.Mobile);
        }

        #region Implementation

        private static AndroidNetworkStatus GetConnectivityStatus(ConnectivityType connectivityType)
        {
            var connectivityManager = (ConnectivityManager)Application.Context.GetSystemService(Context.ConnectivityService);
            var wifiNetworkInfo = connectivityManager.GetNetworkInfo(connectivityType);
            var result = GetNetworkStatus(wifiNetworkInfo);
            return result;
        }

        private static AndroidNetworkStatus GetNetworkStatus(NetworkInfo wifiNetworkInfo)
        {
            var result = AndroidNetworkStatus.Unknown;
            if (wifiNetworkInfo != null)
            {
                if (wifiNetworkInfo.IsAvailable && wifiNetworkInfo.IsConnected)
                {
                    result = AndroidNetworkStatus.Connected;
                }
                else
                {
                    result = AndroidNetworkStatus.Disconnected;
                }
            }
            return result;
        } 

        #endregion
    }

    public enum AndroidNetworkStatus
    {
        Connected,
        Disconnected,
        Unknown
    }