it-swarm.com.de

Wie überprüfe ich den Internetzugang auf Android? InetAddress läuft nie aus

Ich habe ein AsyncTask, das den Netzwerkzugriff auf einen Hostnamen überprüfen soll. Aber die 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();
    }   
}
625
Vidar Vestnes

Netzwerkverbindung/Internetzugang

  • isConnectedOrConnecting() (wird in den meisten Antworten verwendet) sucht nach Netzwerk Verbindungen
  • Verwenden Sie eines der folgenden Verfahren, um festzustellen, ob eines dieser Netzwerke über Internet Zugriff 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;
}

+ konnte auf dem Hauptthread ausgeführt werden

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

B) Stellen Sie eine Verbindung zu einem Socket im Internet her (Fortgeschrittene)

// 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 im UI-Thread nicht ausgeführt werden

Dies funktioniert auf jedem Gerät sehr zuverlässig und ist sehr schnell. Es muss jedoch in einer separaten Task ausgeführt werden (z. B. ScheduledExecutorService oder 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 lassen Sie 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 130 Milliarden Anfragen pro Tag bearbeitet. Sagen wir einfach, Ihre App wäre wahrscheinlich nicht die Rede des Tages.

  • 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 überhaupt einen Fernzugriff auf den Internetzugang haben könnten?)

Extra: One-Shot AsyncTask Beispiel

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/RxAndroid Beispiel (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 */}
492
Levit

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

Geändert ( 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 dem AndroidManifest.xml außerdem die folgende Berechtigung hinzu:

<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, netInfo.isConnected() anstelle von netInfo.isConnectedOrConnecting zu verwenden. Ich denke, das hängt jedoch vom jeweiligen Anwendungsfall ab.

1022
gar

Sie müssen nicht komplex sein. Die einfachste und einfachste Möglichkeit besteht darin, die Berechtigung ACCESS_NETWORK_STATE zu verwenden und einfach 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 auch requestRouteToHost verwenden, wenn Sie einen bestimmten Host- und Verbindungstyp (WLAN/Mobiltelefon) im Auge haben.

Sie benötigen außerdem:

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

in Ihrem Android Manifest.

293
Eddie

Damit getActiveNetworkInfo() funktioniert, müssen Sie dem Manifest Folgendes hinzufügen.

<uses-permission Android:name="Android.permission.ACCESS_NETWORK_STATE" />
63
azelez

überprüfe 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 starte den Test:

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

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

EDIT EDIT: 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, um dies zu sagen

ConnectivityManager cm = Context.getSystemService(Context.CONNECTIVITY_SERVICE);
cm.yourMethodCallHere();
45
Chinmay Kanchi

Gefunden bei und modifiziert (!) 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 Berechtigung INTERNET, 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;
    }
}
26
Ajhar

Ich habe diesen Code gemacht, es ist der einfachste und es ist nur ein Boolescher Code. indem Sie if(isOnline()){ fragen

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

Stellen Sie sicher, dass Sie die richtigen Berechtigungen INTERNET und ACCESS_NETWORK_STATE 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;
}
15

Das 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;
}
12
Musculaa

Es gibt mehr als einen Weg

Erstens, kürzester, aber ineffizienter Weg

Nur Network State Permission erforderlich

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

Dann ist 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 in den Antworten zu sehen, ist ConnectivityManager eine Lösung, ich habe sie gerade in eine Methode eingefügt, die eine vereinfachte Methode ist, die alle verwenden
ConnectivityManager gibt true zurück, wenn ein Netzwerkzugriff und kein Internetzugang besteht. Wenn Ihr WLAN mit einem Router verbunden ist, der Router jedoch kein Internet hat, wird true zurückgegeben und die Verfügbarkeit der Verbindung überprüft

Zweitens effizienter Weg

Netzwerkstatus und Internet-Berechtigungen erforderlich

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

Dann ist 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
            }

        }


    }

Rufen Sie CheckInternetAsyncTask an

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

Einige Erklärungen:

  • sie müssen das Internet auf AsyncTask überprüfen, andernfalls kann es in einigen Fällen Android.os.NetworkOnMainThreadException auslösen

  • ConnectivityManager wird verwendet, um den Netzwerkzugriff zu überprüfen, wenn true die Anforderung sendet (Ping)

  • Request send to 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, read this . Wenn Sie eine Website haben, ist es vorzuziehen, Ihre Website anstelle von Google zu platzieren, nur wenn Sie sie in der App verwenden

  • Das Zeitlimit kann in einem Bereich von 20 ms bis 2000 ms geändert werden. In der Regel werden 1500 ms verwendet

9
Mohamed Embaby

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 also keine Internetverbindung hat und Ihr Gerät mit ihm 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 auszuführen (zB an www.google.com) und den Status zu überprüfen, falls vorhanden 200 OK alles ist in Ordnung und Ihr Gerät verfügt über eine Internetverbindung.

8
Nickolaus

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 benötigt:

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

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

8
Jared Burrows

Ein wichtiger Anwendungsfall für mobile Geräte ist, um sicherzustellen, dass eine tatsächliche Verbindung besteht. Dies ist ein häufiges Problem, wenn ein mobiler Benutzer ein WLAN-Netzwerk mit einem "Captive Portal" betritt, in dem er sich anmelden muss. Ich verwende diese Sperrfunktion 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;
}
7
user1528493

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;
}
6
Emre Yazici

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

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 Activity-Instanz (Kontext) in die Verbindungshandlerklasse verschieben, um den Verbindungsstatus dort zu überprüfen. Wenn keine Verbindung (WLAN, Netzwerk) verfügbar ist, wird die UnknownHostException abgefangen 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 derselben Klasse behandeln (mein Server antwortet immer mit einer JSON-Zeichenfolge).

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

}
5
user2912903

Die Überprüfung des Netzwerk-/Internetverbindungsstatus von Android ist nicht kompliziert. Die folgende Klasse DetectConnection 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 So überprüfen Sie den Android Netzwerk-/Internetkonnektivitätsstatus

5
JSupport

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;
    }
    }
5
Lo Juego

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 Unable to Resolve Host beheben

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 Sie es jetzt wie,

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

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

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;
    }
5
Akshay Paliwal

Mit dieser Methode können Sie zwischen einer sehr schnellen Methode (für Echtzeit-Feedback) und einer langsameren Methode (für einmalige Überprüfungen, die Zuverlässigkeit erfordern) wählen.

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

Es folgt der Code aus meiner Klasse Utils:

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

Es ist sehr wichtig zu überprüfen, ob eine Verbindung mit isAvailable () besteht und ob eine Verbindung hergestellt werden kann mit 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();
}

und Sie können den Typ des aktiven WiFi Netzwerks bestimmen:

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

vergiss die erlaubnisse nicht:

    <uses-permission Android:name="Android.permission.ACCESS_NETWORK_STATE" />
   <uses-permission Android:name="Android.permission.INTERNET" />
4
Jorgesys

Die anderen Antworten, die ConnectivityManager verwenden, sind falsch, da eine Netzwerkverbindung nicht bedeutet, dass Sie über einen Internetzugang verfügen. Beispielsweise ist der Benutzer möglicherweise mit dem WiFi-Portal eines Coffeeshops verbunden, kann jedoch nicht auf das Internet zugreifen. Um zu überprüfen, ob das Internet verfügbar ist, müssen Sie versuchen, eine Verbindung zu einem tatsächlichen Server herzustellen. Wenn Sie dies tun möchten, denken Sie normalerweise an einen bestimmten Server, zu dem Sie eine Verbindung herstellen möchten. Überprüfen Sie daher, ob Sie eine Verbindung zu diesem Server herstellen können. Hier ist eine einfache Methode zum Überprüfen der Konnektivität zu einem Server.

private boolean isOnTheInternet() {
    try {
        URLConnection urlConnection = new URL("http://yourserver").openConnection();
        urlConnection.setConnectTimeout(400);
        urlConnection.connect();
        return true;
    } catch (Exception e) {
        return false;
    }
}

Der Grund für das Setzen des ConnectTimeout ist, dass es ansonsten standardmäßig das Timeout TCP verwendet, das viele Sekunden lang sein kann.

Beachten Sie auch, dass Sie dies mit Android nicht auf Ihrem Haupt-Thread ausführen können.

4
miguel
4
kreker

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

Ich habe alle erforderlichen Methoden und Klassen zur Überprüfung der aktiven Internetverbindung angegeben.

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 anhand des folgenden Codes überprüfen, ob das Internet aktiv ist:

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

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

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

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
    }
3
Has AlTaiar

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 also die Methode eine gültige Verbindung zum Internet findet, ist der Rückgabewert true, andernfalls false, wenn 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 keine Internetverbindung besteht), wird der Benutzer zum Wi-Fi-Bereich Android geleitet, wo er aufgefordert wird, eine Verbindung zu einem Wi-Fi-Hotspot herzustellen.

3

Es ist so großartig, mehr als eine Möglichkeit zum Codieren zu haben. Hier ist mein Beispiel.

ConnectivityManager icheck = getSystemService(Context.CONNECTIVITY_SERVICE);

TextView tv = findViewById(R.id.textView1);

boolean wifi = icheck.getActiveNetworkInfo() != null;
        if(wifi) {
        tv.setText("Internet is on.");  
        } else {
             tv.setText("Internet is off.");    
        }

Viel Glück.

2
public boolean isOnline() {
    boolean var = false;
    ConnectivityManager cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
    if ( cm.getActiveNetworkInfo() != null ) {
        var = true;
    }
    return var;
} 

Ich habe es so gemacht. Ein bisschen kürzer und lesbarer, denke ich.

Prost!

Saiyajin

2
InsaurraldeAP

Wenn Sie API 23 oder höher verwenden, können Sie jetzt mithilfe von NetworkCapabilities.NET_CAPABILITY_VALIDATED überprüfen, ob das Internet aktiv ist. Dies wird durch den Ping-Dienst von Google unterstützt.

ConnectivityManager.NetworkCallback networkCallback = new ConnectivityManager.NetworkCallback() {
    @Override
    public void onLost(Network network) {
        // handle network lost
    }

    @Override
    public void onAvailable(Network network) {
        ConnectivityManager cm = (ConnectivityManager) getApplicationContext().getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo info = cm.getNetworkInfo(network);
        boolean isConnected = (info != null && info.isConnectedOrConnecting());

        if (isConnected) {
            NetworkCapabilities nc = cm.getNetworkCapabilities(network);
            if (nc != null) {
                boolean isInternetValid = nc.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED);
                if (isInternetValid) {
                    // internet is valid
                }
            }
        }
    }
};

NetworkRequest request = new NetworkRequest.Builder().addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET).build();
ConnectivityManager connectivityManager = (ConnectivityManager) getApplicationContext().getSystemService(Context.CONNECTIVITY_SERVICE);
connectivityManager.registerNetworkCallback(request, networkCallback);
2
Keeeeeenw
public static boolean isNetworkAvailable(Context ctx) {
ConnectivityManager connMgr = (ConnectivityManager)ctx.getSystemService(Context.CONNECTIVITY_SERVICE);
if(connMgr.getNetworkInfo(ConnectivityManager.TYPE_WIFI).isConnected() ||
    connMgr.getNetworkInfo(ConnectivityManager.TYPE_MOBILE).isConnected()){
        return true;
}

return false;
 } 

benutzer dies

2
geekdev786

Die einfachste Lösung wäre

In den meisten Fällen wird die Internetverbindung nur überprüft, wenn eine Verbindung zum Remote-Server hergestellt werden soll. Die einfachste und beste Lösung besteht darin, Ihren Server wie folgt anzupingen.

public boolean isConnected() {
    final String command = "ping -c 1 yourExmapleDomain.com";
    boolean isConnected = false;
    try {
        isConnected = Runtime.getRuntime().exec(command).waitFor() == 0;
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
    return isConnected;
}
1
Muhammad

Mit diesem Code können Sie feststellen, ob das Internet aktiviert ist oder nicht.

public final boolean isInternetOn() {
        ConnectivityManager conMgr = (ConnectivityManager) this.con
                .getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo info = conMgr.getActiveNetworkInfo();
        return (info != null && info.isConnected());
}

Außerdem sollten Sie die folgenden Berechtigungen bereitstellen

<uses-permission Android:name="Android.permission.INTERNET" />
<uses-permission Android:name="Android.permission.ACCESS_NETWORK_STATE" />
1
Vishnu M A
 public static boolean isNetworkAvailable(Context context) {
    boolean flag = checkNetworkAvailable(context);

    if (!flag) {
        Log.d("", "No network available!");
    } 
    return flag;
}


private static boolean checkNetworkAvailable(Context context) {
    ConnectivityManager connectivityManager
            = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
    return activeNetworkInfo != null;
}
1
Gautam Surani

Wenn Sie nach der Internetverbindung suchen müssen, verwenden Sie diese Methode, indem Sie einen Ping-Befehl an den Server senden:

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

Entweder können Sie check through using port verwenden

public boolean checkIntCON() {
    try {
        Socket sock = new Socket();
        SocketAddress sockaddr = new InetSocketAddress("8.8.8.8", 80); 
        // port will change according to protocols

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

        return true;
    } catch (IOException e) { return false; }
}
1
E J Chathuranga

Ich habe mit fast 5+ verschiedenen Android Ansätzen versucht und festgestellt, dass dies die beste Lösung ist, die von Google speziell für Android bereitgestellt wird:

  try {
  HttpURLConnection urlConnection = (HttpURLConnection)
  (new URL("http://clients3.google.com/generate_204")
  .openConnection());
  urlConnection.setRequestProperty("User-Agent", "Android");
  urlConnection.setRequestProperty("Connection", "close");
  urlConnection.setConnectTimeout(1500);
  urlConnection.connect();
  if (urlConnection.getResponseCode() == 204 &&
  urlConnection.getContentLength() == 0) {
  Log.d("Network Checker", "Successfully connected to internet");
  return true;
  }
  } catch (IOException e) {
  Log.e("Network Checker", "Error checking internet connection", e);
  }

Es ist faster, efficient und accurate als jede andere verfügbare Lösung.

1
0xAliHn
if(isConnected()){
                Toast.makeText(getApplication(),"Thank you",Toast.LENGTH_SHORT).show();
        }
        else{

            AlertDialog.Builder builder =
                    new AlertDialog.Builder(this, R.style.AppCompatAlertDialogStyle);
            builder.setTitle("Amar Bhat");
            builder.setMessage("Oops...You are not connected to Internet!!!");
            builder.setPositiveButton("OK", null);
            builder.setNegativeButton("Cancel", null);
            builder.show();
            //Toast.makeText(getApplication(),"You are not connected",Toast.LENGTH_SHORT).show();
        }




//And outside the class define isConnected()

 public boolean isConnected(){
        ConnectivityManager connMgr = (ConnectivityManager) getSystemService(Activity.CONNECTIVITY_SERVICE);
        NetworkInfo networkInfo = connMgr.getActiveNetworkInfo();
        if (networkInfo != null && networkInfo.isConnected())
            return true;
        else
            return false;
    }

// In minifest add these permission
<uses-permission Android:name="Android.permission.INTERNET" />

    <uses-permission Android:name="Android.permission.ACCESS_NETWORK_STATE" />
0
Amareshwar Bhat

Dies ist die einfachste und einfachste Möglichkeit, die Internetverbindung auf WLAN und mobile Daten zu überprüfen.

public static boolean isConnected(Activity _context) {
        if (_context != null) {
            ConnectivityManager connMgr = (ConnectivityManager) _context.getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo activeInfo = connMgr.getActiveNetworkInfo();
            if (activeInfo != null && activeInfo.isConnected()) {
                boolean wifiConnected = activeInfo.getType() == ConnectivityManager.TYPE_WIFI;
                boolean mobileConnected = activeInfo.getType() == ConnectivityManager.TYPE_MOBILE;

                if (wifiConnected || mobileConnected) {
                    Log.d(TAG, "Wifi Connected ");
                    return true;
                } else {
                    showAlert(_context,_context.getString(R.string.err_no_internet));
                    return false;
                }
            } else {
                showAlert(_context,_context.getString(R.string.err_no_internet));
                return false;
            }
        } else {
            Log.e(TAG, "networkConnectivity: Context NULL");

        }
        return false;
    }
0
Faizal Abbas

Hier ist ein moderner Code, der ein AsynTask verwendet, um ein Problem zu umgehen, bei dem Android abstürzt, wenn Sie versuchen, eine Verbindung zum Hauptthread herzustellen, und eine Warnung mit einer Option zum Spülen und Wiederholen für den Benutzer einführt.

class TestInternet extends AsyncTask<Void, Void, Boolean> {
    @Override
    protected Boolean doInBackground(Void... params) {
        try {
            URL url = new URL("http://www.google.com");
            HttpURLConnection urlc = (HttpURLConnection) url.openConnection();
            urlc.setConnectTimeout(3000);
            urlc.connect();
            if (urlc.getResponseCode() == 200) {
                return true;
            }
        } catch (MalformedURLException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
            return false;
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return false;
        }
        return false;
    }

    @Override
    protected void onPostExecute(Boolean result) {
        if (!result) { // code if not connected
            AlertDialog.Builder builder = new AlertDialog.Builder(MainActivity.this);
            builder.setMessage("An internet connection is required.");
            builder.setCancelable(false);

            builder.setPositiveButton(
                    "TRY AGAIN",
                    new DialogInterface.OnClickListener() {
                        public void onClick(DialogInterface dialog, int id) {
                            dialog.cancel();
                            new TestInternet().execute();
                        }
                    });


            AlertDialog alert11 = builder.create();
            alert11.show();
        } else { // code if connected
            doMyStuff();
        }
    }
}

...

new TestInternet().execute();
0

Hier ist die Kotlin Version, die ich für die Erreichbarkeitsprüfung benutze,

Kotlin MyReachability

object MyReachability {

    private val REACHABILITY_SERVER = "http://google.com" // can be any URL you want

    private fun hasNetworkAvailable(context: Context): Boolean {
        val service = Context.CONNECTIVITY_SERVICE
        val manager = context.getSystemService(service) as ConnectivityManager?
        val network = manager?.activeNetworkInfo
        Log.d(classTag, "hasNetworkAvailable: ${(network != null)}")
        return (network != null)
    }

    fun hasInternetConnected(context: Context): Boolean {
        if (hasNetworkAvailable(context)) {
            try {
                val connection = URL(REACHABILITY_SERVER).openConnection() as HttpURLConnection
                connection.setRequestProperty("User-Agent", "Test")
                connection.setRequestProperty("Connection", "close")
                connection.connectTimeout = 1500
                connection.connect()
                Log.d(classTag, "hasInternetConnected: ${(connection.responseCode == 200)}")
                return (connection.responseCode == 200)
            } catch (e: IOException) {
                Log.e(classTag, "Error checking internet connection", e)
            }
        } else {
            Log.w(classTag, "No network available!")
        }
        Log.d(classTag, "hasInternetConnected: false")
        return false
    }
}

Sie können REACHABILITY_SERVER sogar als Parameter übergeben, basierend auf Richtlinien und Einschränkungen. Wenn Sie sich beispielsweise in China befinden, können Sie https://baidu.com eher https://google.com .

Aufrufbeispiel,

val webLoaderThread = Thread {
   if (MyReachability.hasInternetConnected(this)){
       runOnUiThread {
           //mWebView.loadUrl(LANDING_SERVER) // connected
       }
   } else {
       runOnUiThread {
           //showDialogNoNetwork() // not connected
       }
   }
}
webLoaderThread.start()

Android-Berechtigungen

Vergessen Sie nicht, diese unten aufgeführten Berechtigungen zu Ihrem AndroidManifest.xml hinzuzufügen.

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

Sie können das Internet auch mit folgendem Code überprüfen:

 public class CheckInternetConnection {
        public Context context = null;

        public CheckInternetConnection(Context ctx) {
            this.context = ctx;
        }

        public boolean CheckInternet() {
            return isOnline();
        }
        public Boolean isOnline() 
        {
            try {
                if(isNetAvailable(context))
                    return true;
                else
                {
                    try {
                        URL url = new URL("http://www.google.com");
                        HttpURLConnection urlc = (HttpURLConnection) url
                                .openConnection();
                        urlc.setRequestProperty("User-Agent", "Test");
                        urlc.setRequestProperty("Connection", "close");
                        urlc.setConnectTimeout(3000); // This is time limit if the
                        // connection time limit
                        try {
                            urlc.connect();
                            Log.e("TAG", " urlc ----------" + urlc.getResponseCode());
                            if (urlc.getResponseCode() == 200) {
                                return true;
                            }
                        }catch (Exception e){
                            e.printStackTrace();
                        }
                    } catch (MalformedURLException e1) {
                        e1.printStackTrace();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }catch (Exception e){
                e.printStackTrace();
            }

            return false;        
        }

         public synchronized static boolean isNetAvailable(Context context){

             try{
             boolean isNetAvailable=false;
             if ( context != null )
             {
                 ConnectivityManager mgr = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
                 if ( mgr != null )
                 {
                     boolean mobileNetwork = false;
                     boolean wifiNetwork = false;
                     boolean wiMaxNetwork = false;

                     boolean mobileNetworkConnecetd = false;
                     boolean wifiNetworkConnecetd = false;
                     boolean wiMaxNetworkConnected = false;

                     NetworkInfo mobileInfo = mgr.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
                     NetworkInfo wifiInfo = mgr.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
                     NetworkInfo wiMaxInfo = mgr.getNetworkInfo(ConnectivityManager.TYPE_WIMAX);

                     if ( mobileInfo != null )
                         mobileNetwork = mobileInfo.isAvailable();                   

                     if ( wifiInfo != null )
                         wifiNetwork = wifiInfo.isAvailable();

                     if(wiMaxInfo != null)
                         wiMaxNetwork = wiMaxInfo.isAvailable();

                     if(wifiNetwork == true)
                         wifiNetworkConnecetd = wifiInfo.isConnectedOrConnecting();
                     if(mobileNetwork == true)
                         mobileNetworkConnecetd = mobileInfo.isConnectedOrConnecting();
                     if(wiMaxNetwork == true)
                         wiMaxNetworkConnected = wiMaxInfo.isConnectedOrConnecting();

                     isNetAvailable = ( mobileNetworkConnecetd || wifiNetworkConnecetd || wiMaxNetworkConnected );
                 }
             }
             return isNetAvailable;
             }catch(NullPointerException e)
             {
                 return false;
             }catch(Exception e)
             {
                 return false;
             }
         }


    }
0
ViramP

Hier ist die optimale Methode zur Überprüfung der Internetverbindung. Diese Methode führt eine Reihe von Überprüfungen durch: "Befindet sich das Telefon nicht im Flugzeugmodus, ist das Telefon mit einem Netzwerk verbunden, usw.". Wenn alle Prüfungen wahr sind, lädt die Methode eine Datei aus dem Internet herunter und prüft, ob der Inhalt mit einem erwarteten Wert übereinstimmt.

Die Vorteile dieser Methode im Vergleich zu anderen Methoden, mit denen ein Server per Ping auf Internetverbindung überprüft wird, sind:

  1. Die Laufzeit von Android variiert auf verschiedenen Telefonen - daher können Sie diese Befehle möglicherweise nicht immer ausführen, wie hier gezeigt: Warum funktioniert Ping auf einigen Geräten und auf anderen nicht?

  2. Das Pingen eines Servers funktioniert nicht immer, da Anmeldeseiten/Weiterleitungen in WLAN-Netzwerken den falschen Eindruck einer Verbindung erwecken können.

Diese Antwort ist in Kotlin geschrieben und verwendet die Bibliothek Fuel , um eine Datei mit der MethodefetchUrlAsString aus dem Internet herunterzuladen. Sie können jedoch jede Bibliothek ersetzen, solange Sie sicherstellen, dass Ihre HTTP-Anforderung nicht vorhanden ist zwischengespeichert. Stellen Sie sich showConnectionWarning() und hideConnectionWarning() als äquivalent zu internet connection status = false bzw. internet connection status = true vor.

private val networkReceiver = object : BroadcastReceiver() {

    override fun onReceive(context: Context?, intent: Intent?) {

        val activeNetworkInfo = (context?.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager).activeNetworkInfo

        if (activeNetworkInfo != null) {
            if (activeNetworkInfo.isConnectedOrConnecting) {
                //Launches a coroutine to fetch file asynchronously 
                launch {
                    try {
                        //Downloads file from url on the internet - use any library you want here.  
                        val connectionStatus = fetchUrlAsString(<url_for_file_on_internet>)
                        //check if the contents of the file is as expected
                        if (connectionStatus == "Connected To Database") {
                            hideConnectionWarning()
                        } else {
                            showConnectionWarning()
                        }
                    } catch (e: Exception) {
                        //Catches an exception - fetchUrlAsString only throws an exception if there is no internet 
                        showConnectionWarning()
                    }
                }
            } else {
                showConnectionWarning()
            }
        } else {
            showConnectionWarning()
        }
    }
}

private suspend fun fetchUrlAsString(url: String): String = suspendCoroutine { cont ->
    url.httpGet().header(Pair("pragma", "no-cache"), Pair("cache-control", "no-cache")).responseString { _, _, result ->

        when (result) {
            is Result.Failure -> {
                cont.resumeWithException(result.getException())
            }
            is Result.Success -> {
                cont.resume(result.value)
            }
        }

    }
}

Sie benötigen die folgenden Berechtigungen:

<uses-permission Android:name="Android.permission.ACCESS_NETWORK_STATE" />
<uses-permission Android:name="Android.permission.INTERNET" />
0
Roymunson

Anstatt die WLAN-Verbindung oder die mobile Datenverbindung zu überprüfen, schlagen Sie eine beliebige gehostete Domain an. Damit können Sie prüfen, ob die WIFI/Mobile-Verbindung eine Verbindung zum öffentlichen Internet herstellen kann.

Das Folgende wird zurückgegeben, wenn Ihr Mobilgerät eine Verbindung mit der bereitgestellten öffentlichen Domain herstellen kann.

boolean isReachable()
        {
            boolean connected = false;
            String instanceURL = "Your trusted domain name";
            Socket socket;
            try {
                socket = new Socket();
                SocketAddress socketAddress = new InetSocketAddress(instanceURL, 80);
                socket.connect(socketAddress, 5000);
                if (socket.isConnected()) {
                    connected = true;
                    socket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                socket = null;
            }
            return connected;
        }

Hoffe, es wird hilfreich sein ..

0
Ragu

Die meisten Antworten in diesem Thread prüfen nur, ob eine Verbindung verfügbar ist, aber nicht, ob diese Verbindung funktioniert. Andere Antworten sind nicht geräteweit. Meine Lösung sollte auf jedem Gerät funktionieren.

Sie können meinen Code in Ihrer Hauptaktivität ablegen, bevor Sie die App starten. Es wird schnell festgestellt, ob eine tatsächliche Internetverbindung besteht. Wenn dies nicht der Fall ist, wird das Dialogfeld sofort gelöscht und die App wird gestartet Die App benötigt eine Internetverbindung.

final AlertDialog alertDialog = new AlertDialog.Builder(this).create();
        alertDialog.setTitle("Checking Connection");
        alertDialog.setMessage("Checking...");
        alertDialog.show();
        new CountDownTimer(5000, 1000) {
            @Override
            public void onTick(long millisUntilFinished) {

                new Thread(new Runnable() {
                    public void run() {
                        try {
                            URL url = new URL("http://web.mit.edu/");
                            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
                            connection.setRequestMethod("GET");
                            connection.setConnectTimeout(5000);
                            isConnected = connection.getResponseCode() == HttpURLConnection.HTTP_OK;
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }).start();

                if (isConnected == false){
                    alertDialog.setMessage("Try " +  (5 - millisUntilFinished/1000) + " of 5.");
                } else {
                    alertDialog.dismiss();
                }
            }
            @Override
            public void onFinish() {
                if (isConnected == false) {
                    alertDialog.dismiss();
                    new AlertDialog.Builder(activity)
                            .setTitle("No Internet")
                            .setMessage("Please connect to Internet first.")
                            .setPositiveButton(Android.R.string.yes, new DialogInterface.OnClickListener() {
                                public void onClick(DialogInterface dialog, int which) {
                                    // kill the app?
                                }
                            })
                            .setIcon(Android.R.drawable.ic_dialog_alert)
                            .show();
                } else {
                    // Launch the app
                }
            }
        }.start();
0
D.Snap

Android bietet die ConnectivityManager-Klasse, um Informationen zum Internetverbindungsstatus zu erhalten. Die folgende Methode ist sehr nützlich, um den Status der Internetverbindung zu ermitteln.

Fügen Sie zuerst die Berechtigung INTERNET und ACCESS_NETWORK_STATE zu AndroidManifest.xml hinzu

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

Verwenden Sie dann die folgende Methode, um zu überprüfen, ob das Gerät mit dem Internet verbunden ist oder nicht. Diese Methode gibt true zurück, wenn das Gerät mit dem Internet verbunden ist.

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

Referenzlink: - http://www.androidtutorialshub.com/Android-check-internet-connection-status/

0
lalit vasan

Vergessen Sie nicht, diese Berechtigungen zu Ihrem Manifest hinzuzufügen:

<uses-permission Android:name="Android.permission.INTERNET" />
<uses-permission Android:name="Android.permission.ACCESS_NETWORK_STATE" />
0
Context
public boolean isNetworkAvailable(Context context) {
    ConnectivityManager connectivityManager
            = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
    return activeNetworkInfo != null && activeNetworkInfo.isConnected();
}

Hier ist die Erlaubnis, die Sie benötigen:

<uses-permission Android:name="Android.permission.ACCESS_NETWORK_STATE"/>
0
alireza amini