Ich habe eine AsyncTask, die den Netzwerkzugriff auf einen Hostnamen überprüfen soll. Aber das doInBackground()ist nie abgelaufen. Hat jemand eine Ahnung?

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

Netzwerkverbindung / Internetzugang

• isConnectedOrConnecting()Kontrollen für alle (in den meisten Antworten verwendet) Netzwerk - Verbindung
• Verwenden Sie eine der folgenden Methoden, um festzustellen, ob eines dieser Netzwerke über einen Internetzugang verfügt

A) Pingen Sie einen Server (einfach)

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

+ könnte auf Haupt-Thread laufen

- funktioniert auf einigen alten Geräten (Galays S3 usw.) nicht, blockiert eine Weile, wenn kein Internet verfügbar ist.

B) Stellen Sie eine Verbindung zu einer Steckdose im Internet her (erweitert)

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

+sehr schnell (so oder so), funktioniert auf allen Geräten, sehr zuverlässig

- kann nicht auf dem UI-Thread ausgeführt werden

Dies funktioniert auf jedem Gerät sehr zuverlässig und ist sehr schnell. Es muss jedoch in einer separaten Aufgabe ausgeführt werden (z . B. ScheduledExecutorServiceoder AsyncTask).

Mögliche Fragen

• Ist es wirklich schnell genug?

  Ja sehr schnell ;-)

• Gibt es keine zuverlässige Möglichkeit, das Internet zu überprüfen, außer etwas im Internet zu testen?

  Nicht so weit ich weiß, aber lass es mich wissen, und ich werde meine Antwort bearbeiten.

• Was ist, wenn der DNS ausgefallen ist?

  Google DNS (z. B. 8.8.8.8) ist das größte öffentliche DNS der Welt. Ab 2013 wurden täglich 130 Milliarden Anfragen bearbeitet. Sagen wir einfach, Ihre App wäre wahrscheinlich nicht das Tagesgespräch.

• Welche Berechtigungen sind erforderlich?

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

  Nur Internetzugang - Überraschung ^^ (Übrigens haben Sie jemals darüber nachgedacht, wie einige der hier vorgeschlagenen Methoden ohne diese Erlaubnis sogar einen Fernkleber über den Internetzugang haben könnten?)

Extra: One-Shot- AsyncTaskBeispiel

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: One-Shot- RxJava/RxAndroidBeispiel (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 */}

Befindet sich das Gerät im Flugzeugmodus (oder vermutlich in anderen Situationen, in denen kein Netzwerk verfügbar ist), cm.getActiveNetworkInfo()müssen nullSie eine nullPrüfung hinzufügen .

Modifiziert ( Eddies Lösung ) unten:

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

Fügen Sie außerdem die folgende Berechtigung hinzu AndroidManifest.xml:

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

Ein weiterer kleiner Punkt: Wenn Sie zum angegebenen Zeitpunkt unbedingt eine Netzwerkverbindung benötigen, ist es möglicherweise besser, diese zu verwenden netInfo.isConnected()als netInfo.isConnectedOrConnecting. Ich denke, dies hängt jedoch vom jeweiligen Anwendungsfall ab.

Keine Notwendigkeit, komplex zu sein. Die einfachste und einfachste ACCESS_NETWORK_STATEMethode besteht darin, die Berechtigung zu verwenden und nur eine verbundene Methode zu erstellen

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

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

Sie können es auch verwenden, requestRouteToHostwenn Sie einen bestimmten Host- und Verbindungstyp (WLAN / Mobil) im Auge haben.

Sie benötigen außerdem:

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

in Ihrem Android-Manifest.

Um getActiveNetworkInfo()zur Arbeit zu gelangen , müssen Sie dem Manifest Folgendes hinzufügen.

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

Schauen Sie sich die ConnectivityManager-Klasse an. Mit dieser Klasse können Sie Informationen zu den aktiven Verbindungen auf einem Host abrufen. http://developer.android.com/reference/android/net/ConnectivityManager.html

EDIT: Sie können verwenden

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

oder

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

und analysieren Sie die DetailedState-Enumeration des zurückgegebenen NetworkInfo-Objekts

BEARBEITEN BEARBEITEN: Um herauszufinden, ob Sie auf einen Host zugreifen können, können Sie verwenden

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

Offensichtlich verwende ich Context.getSystemService (Context.CONNECTIVITY_SERVICE) als Proxy

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

Überprüfen Sie diesen Code ... es hat bei mir funktioniert :)

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

Dann definiere ich den Handler:

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

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

        } else { // code if connected

        }   
    }
};

... und starten Sie den Test:

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

Gefunden bei und geändert (!) Von diesem Link :

Fügen Sie in Ihrer Manifestdatei mindestens Folgendes hinzu:

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

Sie haben wahrscheinlich bereits die INTERNET-Berechtigung, wenn Sie darauf zugreifen. Dann ist eine boolesche Funktion, mit der die Konnektivität getestet werden kann:

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

Ich habe diesen Code gemacht, er ist der einfachste und nur ein Boolescher Wert. durch Fragenif(isOnline()){

Sie erhalten, wenn eine Verbindung besteht und wenn eine Verbindung zu einer Seite hergestellt werden kann, den Statuscode 200(stabile Verbindung).

Stellen Sie sicher, dass Sie die richtigen INTERNETund ACCESS_NETWORK_STATEBerechtigungen hinzufügen .

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

Es funktioniert bei mir:

So überprüfen Sie die Netzwerkverfügbarkeit:

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

So überprüfen Sie den Internetzugang:

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

Es gibt mehr als einen Weg

Erstens der kürzeste, aber ineffiziente Weg

Netzwerkstatusberechtigung nur erforderlich

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

Dann diese Methode,

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

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

        return isConnected;

    }

Wie aus den Antworten hervorgeht, ConnectivityManagerhandelt es sich um eine Lösung. Ich habe sie nur innerhalb einer Methode hinzugefügt. Dies ist eine vereinfachte Methode. Alle Verwendungszwecke geben
ConnectivityManagertrue zurück, wenn ein Netzwerkzugriff und kein Internetzugang vorhanden ist. Wenn Ihr WLAN mit einem Router verbunden ist, der Router jedoch kein Internet hat Gibt true zurück und überprüft die Verfügbarkeit der Verbindung

Zweitens effizienter Weg

Netzwerkstatus und Internetberechtigungen erforderlich

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

Dann diese Klasse,

 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
            }

        }


    }

Anruf CheckInternetAsyncTask

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

Einige Erklärungen :-

• Sie müssen das Internet einschalten AsyncTask, sonst kann es android.os.NetworkOnMainThreadExceptionin einigen Fällen werfen

• ConnectivityManager Wird verwendet, um den Netzwerkzugriff zu überprüfen, wenn true eine Anforderung sendet (Ping).

• Anfrage senden an http://clients3.google.com/generate_204, Diese bekannte URL gibt bekanntermaßen eine leere Seite mit einem HTTP-Status zurück. 204 Dies ist schneller und effizienter als http://www.google.com, lesen Sie diese . Wenn Sie eine Website haben, ist es vorzuziehen, Ihre Website anstelle von Google zu platzieren, nur wenn Sie sie in der App verwenden

• Zeitüberschreitung kann Bereich geändert werden (20ms -> 2000ms), 1500ms wird häufig verwendet

Von allem, was ich bisher gesehen habe, sollte der kürzeste und sauberste Weg sein:

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: Dies pingt keinen Host an, sondern überprüft nur den Verbindungsstatus. Wenn Ihr Router keine Internetverbindung hat und Ihr Gerät damit verbunden ist, gibt diese Methode true zurück, obwohl Sie kein Internet haben.
Für einen tatsächlichen Test würde ich empfehlen, eine HttpHead-Anfrage (z. B. an www.google.com) auszuführen und den Status zu überprüfen. Wenn 200 OK, ist alles in Ordnung und Ihr Gerät verfügt über eine Internetverbindung.

Hier ist die Methode, die ich benutze:

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

Überprüfen Sie noch besser, ob es "verbunden" ist:

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

So verwenden Sie die Methode:

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

Erlaubnis erforderlich:

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

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

Ein wichtiger Anwendungsfall auf Mobilgeräten, um sicherzustellen, dass eine tatsächliche Verbindung besteht. Dies ist ein häufiges Problem, wenn ein mobiler Benutzer ein Wifi-Netzwerk mit einem "Captive Portal" betritt, in dem er sich anmelden muss. Ich verwende diese Blockierungsfunktion im Hintergrund, um sicherzustellen, dass eine Verbindung besteht.

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

Sie können über alle Netzwerkverbindungen iterieren und prüfen, ob mindestens eine Verbindung verfügbar ist:

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

Für mich war es keine gute Praxis, den Verbindungsstatus in der Aktivitätsklasse zu überprüfen, weil

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

sollte dort aufgerufen werden, oder Sie müssen Ihre Aktivitätsinstanz (Kontext) in die Verbindungshandlerklasse verschieben, um dort den Verbindungsstatus überprüfen zu können. Wenn keine Verbindung verfügbar ist (WLAN, Netzwerk), erhalte ich die UnknownHostException- Ausnahme:

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

Auf diese Weise kann ich diesen Fall zusammen mit den anderen Fällen in derselben Klasse behandeln (mein Server antwortet immer mit einer JSON-Zeichenfolge).

Es funktioniert bei mir. Versuch es.

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

Diese Methode bietet Ihnen die Möglichkeit einer sehr schnellen Methode (für Echtzeit-Feedback) oder einer langsameren Methode (für einmalige Überprüfungen, die Zuverlässigkeit erfordern).

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

Ich benutze diesen Code anstelle der 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();
    }

Es ist nicht komplex, den Status der Android-Netzwerk- / Internetverbindung zu überprüfen. Die folgende DetectConnectionKlasse hilft Ihnen, diesen Status zu überprüfen:

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

Weitere Informationen finden Sie unter Überprüfen des Android-Netzwerk- / Internetverbindungsstatus

Bester Ansatz:

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

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

Es folgt der Code aus meiner UtilsKlasse:

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

}

Mit dieser Methode können Sie die Netzwerkverfügbarkeit ermitteln.

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

Ich habe die von @Levit bereitgestellte Lösung angewendet und eine Funktion erstellt, die die zusätzliche HTTP-Anforderung nicht aufruft.

Es wird den Fehler beheben 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;
}

Nennen wir es jetzt wie,

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

Dies wird in den Android-Dokumenten http://developer.android.com/training/monitoring-device-state/connectivity-monitoring.html behandelt

Ich habe alle Antworten durchgesehen und mir eine eigene Antwort ausgedacht, die zuerst prüft, ob das Internet verfügbar ist, und ob das Internet verfügbar ist, prüft, ob es aktiv ist oder nicht.

Ich habe alle notwendigen Methoden und Klassen aufgenommen, um nach einer aktiven Internetverbindung zu suchen.

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

Sie können überprüfen, ob das Internet aktiv ist, indem Sie den folgenden Code verwenden:

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

Es ist sehr wichtig zu überprüfen, ob wir eine Verbindung mit isAvailable () haben und ob es möglich ist, eine Verbindung mit isConnected () herzustellen.

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

und Sie können die Art von Netzwerk aktiv derterminate WiFi :

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

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

Vergessen Sie nicht die Berechtigungen:

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

Kotlin und Coroutinen

Ich habe die Funktion in eine platziert ViewModel, die die hat viewModelScope. Mit einem Observable LiveDatainformiere ich eine Aktivität über die Verbindung.

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

Aktivität

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

Erstellen Sie einfach die folgende Klasse, die nach einer Internetverbindung sucht:

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

Diese Klasse enthält einfach eine Methode, die den booleschen Wert des Verbindungsstatus zurückgibt. Wenn die Methode in einfachen Worten eine gültige Verbindung zum Internet findet, lautet der Rückgabewert true, andernfalls, falsewenn keine gültige Verbindung gefunden wird.

Die folgende Methode in der MainActivity ruft dann das Ergebnis der zuvor beschriebenen Methode auf und fordert den Benutzer auf, entsprechend zu handeln:

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

Wenn im obigen Code das Ergebnis falsch ist (daher besteht keine Internetverbindung), wird der Benutzer zum Android-WLAN-Bereich weitergeleitet, wo er aufgefordert wird, eine Verbindung zu einem WLAN-Hotspot herzustellen.

Update 29/06/2015 Wenn Sie Xamarin.Android verwenden und die Konnektivität überprüfen möchten, können Sie ein Nuget-Paket verwenden, das Ihnen diese Funktionalität auf mehreren Plattformen bietet. Gute Kandidaten sind hier und hier . [Ende des Updates]

Die obigen Antworten sind recht gut, aber sie sind alle in Java und fast alle prüfen auf Konnektivität. In meinem Fall musste ich mit einem bestimmten Verbindungstyp verbunden sein und entwickle auf Xamarin.Android. Außerdem übergebe ich keinen Verweis auf meinen Aktivitätskontext in der Hardwareschicht, ich verwende den Anwendungskontext. Hier ist meine Lösung für den Fall, dass jemand mit ähnlichen Anforderungen hierher kommt. Ich habe jedoch noch keine vollständigen Tests durchgeführt. Die Antwort wird aktualisiert, sobald ich mit meinen Tests fertig bin

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
    }