AsyncTaskBir ana bilgisayar adına ağ erişimini kontrol etmesi gereken bir tane var . Ama doInBackground()asla zaman aşımına uğramaz. Kimsenin ipucu var mı?

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

Ağ bağlantısı / İnternet erişimi

• isConnectedOrConnecting()(çoğu cevapta kullanılır) herhangi bir ağ bağlantısını kontrol eder
• Bu ağlardan herhangi birinin internet erişimine sahip olup olmadığını bilmek için aşağıdakilerden birini kullanın

A) Sunucuya Ping Atma (kolay)

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

+ ana iş parçacığında çalışabilir

- bazı eski cihazlarda (Galays S3 vb.) çalışmazsa, internet yoksa bir süre engeller.

B) İnternet'teki bir Sokete Bağlanma (gelişmiş)

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

+çok hızlı (her iki şekilde), tüm cihazlarda çalışır, çok güvenilir

- UI iş parçacığında çalışamaz

Bu, her cihazda çok güvenilir bir şekilde çalışır ve çok hızlıdır. Yine de ayrı bir görevde çalışması gerekir (örn. ScheduledExecutorServiceVeya AsyncTask).

Olası Sorular

• Gerçekten yeterince hızlı mı?

  Evet, çok hızlı ;-)

• İnternette bir şey test etmekten başka interneti kontrol etmenin güvenilir bir yolu yok mu?

  Bildiğim kadarıyla değil, bana bildirin, cevabımı düzenleyeceğim.

• DNS kapalıysa ne olur?

  Google DNS (ör. 8.8.8.8), Dünyadaki en büyük genel DNS'dir. 2013 itibariyle günde 130 milyar talepte bulundu. Diyelim ki uygulamanız muhtemelen günün konuşması olmayacak.

• Hangi izinler gereklidir?

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

  Sadece internet erişimi - sürpriz ^^ (Btw hiç düşündünüz mü, burada önerilen yöntemlerden bazıları bu izin olmadan internet erişimi hakkında nasıl uzak bir yapıştırıcıya sahip olabilir?)

Ekstra: Tek Çekim AsyncTaskÖrneği

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 */ });

Ekstra: Tek Çekim RxJava/RxAndroidÖrneği (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 */}

Cihaz uçak modundaysa (veya muhtemelen kullanılabilir ağın olmadığı başka durumlarda), cm.getActiveNetworkInfo()bu nullnedenle bir nullkontrol eklemeniz gerekir .

Aşağıdaki değiştirildi ( Eddie'nin çözümü ):

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

Ayrıca şu izni de ekleyin AndroidManifest.xml:

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

Bir başka küçük nokta, belirli bir zamanda kesinlikle bir ağ bağlantısına ihtiyacınız varsa, kullanmak netInfo.isConnected()yerine daha iyi olabilir netInfo.isConnectedOrConnecting. Sanırım bu bireysel kullanım senaryosuna bağlı.

Karmaşık olmaya gerek yok. En basit ve çerçeve yöntem ACCESS_NETWORK_STATEizin kullanmak ve sadece bağlantılı bir yöntem yapmaktır

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

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

requestRouteToHostAkılda bir ana bilgisayar ve bağlantı türü (wifi / mobil) varsa da kullanabilirsiniz .

Ayrıca aşağıdakilere de ihtiyacınız olacak:

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

android manifestinizde.

Almak için getActiveNetworkInfo()çalışmak için apaçık için aşağıdakileri eklemeniz gerekir.

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

ConnectivityManager sınıfına bir göz atın. Bir ana bilgisayardaki etkin bağlantılar hakkında bilgi almak için bu sınıfı kullanabilirsiniz. http://developer.android.com/reference/android/net/ConnectivityManager.html

EDIT: kullanabilirsiniz

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

veya

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

ve döndürülen NetworkInfo nesnesinin DetailState numaralandırmasını ayrıştırır

DÜZENLEME DÜZENLEME: Bir ana bilgisayara erişip erişemediğinizi öğrenmek için aşağıdakileri kullanabilirsiniz:

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

Açıkçası, Context.getSystemService (Context.CONNECTIVITY_SERVICE) demek için proxy olarak kullanıyorum

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

Bu kodu kontrol et ... benim için çalıştı :)

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

Sonra işleyiciyi tanımlıyorum:

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

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

        } else { // code if connected

        }   
    }
};

... ve testi başlat:

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

En Found ve bu değiştirilmiş (!) Bağlantı :

Manifest dosyanıza en az şunu ekleyin:

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

Erişiyorsanız muhtemelen İNTERNET izniniz vardır. Sonra bağlantı sınamasına izin veren bir boolean işlevi:

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

Bu kodu yaptım, en basit ve sadece bir boolean. sorarakif(isOnline()){

Bir bağlantı varsa ve bir sayfaya bağlanabilirse durum kodu 200(sabit bağlantı) alırsınız .

Doğru INTERNETve ACCESS_NETWORK_STATEizinleri eklediğinizden emin olun .

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

Benim için çalışıyor:

Ağ kullanılabilirliğini doğrulamak için:

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

İnternet erişimini doğrulamak için:

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

Birden fazla yol var

İlk olarak, en kısa ama verimsiz yol

Yalnızca Ağ Durumu İzni gerekiyor

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

Sonra bu yöntem,

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

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

        return isConnected;

    }

Cevaplarda görüldüğü gibi ConnectivityManagerbir çözüm, sadece bir yöntem içinde ekledim, bu basitleştirilmiş bir yöntemdir
ConnectivityManager, İnternet erişimi değil, bir ağ erişimi varsa tüm kullanım doğru döner, WiFi'nizin bir yönlendiriciye bağlı olduğu, ancak yönlendiricinin internetin olmadığı anlamına gelir. döner, bağlantı kullanılabilirliğini kontrol eder

İkincisi, Verimli bir yol

Ağ Durumu ve İnternet İzinleri gerekli

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

Sonra bu sınıf,

 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
            }

        }


    }

Aramak CheckInternetAsyncTask

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

Bazı Açıklamalar: -

• interneti kontrol etmelisiniz AsyncTask, aksi takdirde android.os.NetworkOnMainThreadExceptionbazı durumlarda

• ConnectivityManager gerçek istek gönderirse ağ erişimini kontrol etmek için kullanılır (Ping)

• İsteği göndermek http://clients3.google.com/generate_204, bu tanınmış URL bilinen bu hızlı ve daha verimli daha bir HTTP durumu 204 ile boş bir sayfa döndürmek için http://www.google.com, okumak bu . web siteniz varsa, yalnızca uygulama içinde kullanıyorsanız, google yerine web sitesi koymak tercih edilir

• Zaman aşımı aralığı değiştirilebilir (20ms -> 2000ms), 1500ms yaygın olarak kullanılır

Şimdiye kadar gördüğüm her şeyden en kısa ve en temiz yol olmalı:

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

Not: Bu herhangi bir ana bilgisayara ping atmaz, sadece linkstatus'u kontrol eder, bu nedenle yönlendiricinizin internet bağlantısı yoksa ve cihazınız ona bağlıysa, internetiniz olmasa bile bu yöntem true değerini döndürür .
Gerçek bir test için bir HttpHead isteği (örn. Www.google.com'a ) gerçekleştirmenizi ve durumunu kontrol etmenizi öneririm , eğer 200 OK ise her şey yolunda ve cihazınızın internet bağlantısı varsa.

İşte kullandığım yöntem:

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

Daha da iyisi, "bağlı" olduğundan emin olun:

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

Yöntemi nasıl kullanacağınız aşağıda açıklanmıştır:

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

İzin gerekli:

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

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

Gerçek bir bağlantının olmasını sağlamak için mobil cihazlarda önemli bir kullanım durumu. Bir mobil kullanıcı, oturum açmaları gereken bir "Kısıtlama Portalı" ile bir Wifi ağına girdiğinde bu yaygın bir sorundur. Bir bağlantıyı sağlamak için arka planda bu engelleme işlevini kullanıyorum.

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

Tüm ağ bağlantıları üzerinden yineleme yapabilir ve kullanılabilir en az bir bağlantı olup olmadığını kontrol edebilirsiniz:

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

Benim için Activity sınıfındaki bağlantı durumunu kontrol etmek iyi bir uygulama değildi, çünkü

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

orada çağrılmalıdır veya orada bağlantı durumunu denetlemek için Etkinlik örneğinizi (bağlam) bağlantı işleyicisi sınıfına doğru itmeniz gerekir Kullanılabilir bir bağlantı (wifi, ağ) olmadığında UnknownHostException özel durumunu yakalarım :

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

Bu şekilde, bu sınıfı aynı sınıftaki diğer durumlarla birlikte ele alabilirim (sunucum her zaman bir json dizesiyle yanıt verir)

Benim için çalışıyor. Denemek.

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

Bu yöntem size gerçekten hızlı bir yöntem (gerçek zamanlı geri bildirim için) veya daha yavaş bir yöntem (güvenilirlik gerektiren bir kerelik kontroller için) seçeneği sunar

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

Im InetAddress yerine bu kodu kullanarak:

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

Android ağ / internet bağlantı durumunu kontrol etmek karmaşık değildir. Aşağıdaki DetectConnectionsınıf bu durumu kontrol etmenize yardımcı olacaktır:

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

Daha fazla bilgi için Android Ağ / İnternet Bağlantı Durumunu Kontrol Etme sayfasını ziyaret edin.

En iyi yaklaşım:

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

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

UtilsSınıfımın kodu :

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

}

Ağ kullanılabilirliğini tespit etmek için bu yöntemi kullanabilirsiniz.

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

@Levit tarafından sağlanan çözümü uyguladım ve ekstra Http İsteği çağırmayacak işlevi oluşturdum.

Hatayı çözecek 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;
}

Şimdi şöyle deyin,

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

Bu, http://developer.android.com/training/monitoring-device-state/connectivity-monitoring.html android dokümanlarında ele alınmıştır.

Tüm cevapları inceledim ve ilk önce Internet'in mevcut olup olmadığını ve Internet'in mevcut olup olmadığını kontrol eden kendi cevabım ile geldim, aktif olup olmadığını kontrol edin.

Etkin Internet bağlantısını kontrol etmek için gerekli tüm yöntem ve sınıfları dahil ettim.

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

İnternet'in aktif olup olmadığını aşağıdaki kodu kullanarak kontrol edebilirsiniz:

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

Çok biz bağlantınız olmadığını kontrol etmek önemlidir IsAvailable () ile bağlantı kurmak mümkün olup olmadığını 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();
}

ağ etkin WiFi türünü deraltabilirsiniz :

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

veya mobil Móvil :

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

izinleri unutma:

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

Kotlin ve coroutines

Bir işlevi vermiş ViewModelsahiptir viewModelScope. Gözlenebilir LiveDatabir bağlantı kullanarak, bir etkinliği bağlantı hakkında bilgilendiririm.

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

Aktivite

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

İnternet bağlantısını kontrol eden aşağıdaki sınıfı oluşturmanız yeterlidir:

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

Bu sınıf, bağlantı durumunun boole değerini döndüren bir yöntem içerir. Bu nedenle, basit bir deyişle, yöntem Internet ile geçerli bir bağlantı bulursa, dönüş değeri true, aksi falsetakdirde geçerli bir bağlantı bulunmazsa.

MainActivity'de aşağıdaki yöntem daha sonra daha önce açıklanan yöntemden sonucu çağırır ve kullanıcıdan buna göre hareket etmesini ister:

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.");
        }
    }

Yukarıdaki kodda, sonuç yanlışsa (bu nedenle internet bağlantısı yoksa, kullanıcı bir wi-fi etkin noktasına bağlanmasının istendiği Android wi-fi paneline alınır.

Güncelleme 29/06/2015 Xamarin.Android kullanıyorsanız ve bağlantı olup olmadığını kontrol etmek istiyorsanız, size bu işlevi birden çok platformda sağlayacak bir Nuget paketi kullanabilirsiniz. İyi adaylar burada ve burada . [Güncelleme Sonu]

Yukarıdaki Yanıtlar oldukça iyi, ancak hepsi Java'da ve neredeyse hepsi bir bağlantı olup olmadığını kontrol ediyor. Benim durumumda, belirli bir bağlantı türü ile bağlantıya ihtiyacım vardı ve Xamarin.Android üzerinde geliştiriyorum. Dahası, Donanım katmanındaki faaliyetlerim Bağlamına başvuru yapmıyorum, Uygulama Bağlamını kullanıyorum. Birisi buraya benzer gereksinimlerle gelirse benim çözümüm burada. Tam test yapmadım, testimi bitirdikten sonra cevabı güncelleyeceğim

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
    }