it-swarm.com.de

Android Internetverbindung prüfen

Ich möchte eine App erstellen, die das Internet verwendet, und ich versuche, eine Funktion zu erstellen, mit der überprüft wird, ob eine Verbindung verfügbar ist. Wenn dies nicht der Fall ist, rufen Sie eine Aktivität auf, die eine Wiederholungsschaltfläche und eine Erläuterung enthält.

Beigefügt ist mein Code, aber ich erhalte den Fehler Syntax error, insert "}" to complete MethodBody.

Jetzt habe ich diese in den Versuch gesetzt, es zum Laufen zu bringen, aber bisher kein Glück ... Jede Hilfe wäre dankbar.

public class TheEvoStikLeagueActivity extends Activity {
    private final int SPLASH_DISPLAY_LENGHT = 3000;

    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle icicle) {
        super.onCreate(icicle);
        setContentView(R.layout.main);

        private boolean checkInternetConnection() {
            ConnectivityManager conMgr = (ConnectivityManager) getSystemService (Context.CONNECTIVITY_SERVICE);
            // ARE WE CONNECTED TO THE NET
            if (conMgr.getActiveNetworkInfo() != null
                    && conMgr.getActiveNetworkInfo().isAvailable()
                    && conMgr.getActiveNetworkInfo().isConnected()) {

                return true;

                /* New Handler to start the Menu-Activity
                 * and close this Splash-Screen after some seconds.*/
                new Handler().postDelayed(new Runnable() {
                    public void run() {
                        /* Create an Intent that will start the Menu-Activity. */
                        Intent mainIntent = new Intent(TheEvoStikLeagueActivity.this, IntroActivity.class);
                        TheEvoStikLeagueActivity.this.startActivity(mainIntent);
                        TheEvoStikLeagueActivity.this.finish();
                    }
                }, SPLASH_DISPLAY_LENGHT);
            } else {
                return false;

                Intent connectionIntent = new Intent(TheEvoStikLeagueActivity.this, HomeActivity.class);
                TheEvoStikLeagueActivity.this.startActivity(connectionIntent);
                TheEvoStikLeagueActivity.this.finish();
            }
        }
    }
195
iamlukeyb

Diese Methode prüft, ob das Mobiltelefon mit dem Internet verbunden ist und gibt true zurück, wenn eine Verbindung besteht:

private boolean isNetworkConnected() {
    ConnectivityManager cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);

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

in manifest,

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

Edit: Diese Methode prüft tatsächlich, ob das Gerät mit dem Internet verbunden ist (Es besteht die Möglichkeit, dass es mit einem Netzwerk verbunden ist, aber nicht mit dem Internet).

public boolean isInternetAvailable() {
    try {
        InetAddress ipAddr = InetAddress.getByName("google.com"); 
        //You can replace it with your name
            return !ipAddr.equals("");

        } catch (Exception e) {
            return false;
    }
}
375
Seshu Vinay

Stellen Sie sicher, dass es mit einem Netzwerk "verbunden" ist:

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

Stellen Sie sicher, dass es mit einem Netzwerk "verbunden" ist:

public boolean isInternetAvailable() {
    try {
        InetAddress address = InetAddress.getByName("www.google.com");
        return !address.equals("");
    } catch (UnknownHostException e) {
        // Log error
    }
    return false;
}

Erlaubnis benötigt:

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

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

70
Jared Burrows

Sie können einfach eine Online-Website wie Google anpingen:

public boolean isConnected() throws InterruptedException, IOException {
    final String command = "ping -c 1 google.com";
    return Runtime.getRuntime().exec(command).waitFor() == 0;
}
48
razzak

Die oben genannten Methoden funktionieren, wenn Sie mit einer WLAN-Quelle oder über Datenpakete für Mobiltelefone verbunden sind. Aber im Falle einer Wi-Fi-Verbindung gibt es Fälle, in denen Sie weiter aufgefordert werden, sich wie in Cafe anzumelden. In diesem Fall schlägt Ihre Anwendung fehl, da Sie mit der Wi-Fi-Quelle, jedoch nicht mit dem Internet verbunden sind.

Diese Methode funktioniert gut.

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

    NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
    if (activeNetwork != null && activeNetwork.isConnected()) {
        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(1000); // mTimeout is in seconds
            urlc.connect();
            if (urlc.getResponseCode() == 200) {
                return true;
            } else {
                return false;
            }
        } catch (IOException e) {
            Log.i("warning", "Error checking internet connection", e);
            return false;
        }
    }

    return false;

}

Verwenden Sie dies in einem vom Hauptthread getrennten Thread, da es einen Netzwerkaufruf ausführt und NetwrokOnMainThreadException auslöst, wenn dies nicht befolgt wird.

Stellen Sie diese Methode auch nicht in onCreate oder eine andere Methode. Stellen Sie es in eine Klasse und greifen Sie darauf zu.

26
Bhargav Jhaveri

Sie können das folgende Snippet verwenden, um die Internetverbindung zu überprüfen.

In beiden Fällen ist es hilfreich, zu überprüfen, welches Typ von NETWORK Connection verfügbar ist, damit Sie den Vorgang auf diese Weise ausführen können.

Sie müssen nur folgende Klasse kopieren und direkt in Ihr Paket einfügen.

/**
 * 
 * @author Pratik Butani
 * 
 */
public class InternetConnection {

    /** CHECK WHETHER INTERNET CONNECTION IS AVAILABLE OR NOT */
    public static boolean checkConnection(Context context) {
        final ConnectivityManager connMgr = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);

        NetworkInfo activeNetworkInfo = connMgr.getActiveNetworkInfo();

        if (activeNetworkInfo != null) { // connected to the internet
            Toast.makeText(context, activeNetworkInfo.getTypeName(), Toast.LENGTH_SHORT).show();

            if (activeNetworkInfo.getType() == ConnectivityManager.TYPE_WIFI) {
                // connected to wifi
                return true;
            } else if (activeNetworkInfo.getType() == ConnectivityManager.TYPE_MOBILE) {
                // connected to the mobile provider's data plan
                return true;
            }
        }
        return false;
    }
}

Jetzt können Sie wie folgt verwenden:

if (InternetConnection.checkConnection(context)) {
    // Its Available...
} else {
    // Not Available...
}

NICHT VERGESSEN, die Erlaubnis zu NEHMEN :):)

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

Sie können je nach Ihren Anforderungen ändern.

Danke.

Die BEARBEITUNG der akzeptierten Antwort zeigt, wie geprüft wird, ob etwas im Internet erreichbar ist. Ich musste zu lange auf eine Antwort warten, wenn dies nicht der Fall war (mit einem WLAN, das KEINE Internetverbindung hat). Leider hat InetAddress.getByName keinen Timeout-Parameter, daher funktioniert der nächste Code wie folgt:

private boolean internetConnectionAvailable(int timeOut) {
    InetAddress inetAddress = null;
    try {
        Future<InetAddress> future = Executors.newSingleThreadExecutor().submit(new Callable<InetAddress>() {
            @Override
            public InetAddress call() {
                try {
                    return InetAddress.getByName("google.com");
                } catch (UnknownHostException e) {
                    return null;
                }
            }
        });
        inetAddress = future.get(timeOut, TimeUnit.MILLISECONDS);
        future.cancel(true);
    } catch (InterruptedException e) {
    } catch (ExecutionException e) {
    } catch (TimeoutException e) {
    } 
    return inetAddress!=null && !inetAddress.equals("");
}
17
Hans

Sie können keine Methode in einer anderen Methode erstellen. Verschieben Sie die Methode private boolean checkInternetConnection() { aus onCreate.

14
MByD

Alle offiziellen Methoden geben nur an, ob ein Gerät für das Netzwerk geöffnet ist oder nicht.
Wenn Ihr Gerät mit Wifi verbunden ist, Wifi jedoch nicht mit dem Internet verbunden ist, schlagen diese Methoden fehl (was häufig vorkommt). Keine eingebaute Netzwerkerkennungsmethode gibt Auskunft über dieses Szenario. Daher wurde die Async Callback-Klasse erstellt, die zurückkehrt in onConnectionSuccess und onConnectionFail

        new CheckNetworkConnection(this, new CheckNetworkConnection.OnConnectionCallback() {

            @Override
            public void onConnectionSuccess() {
   Toast.makeText(context, "onSuccess()", toast.LENGTH_SHORT).show();
            }

            @Override
            public void onConnectionFail(String msg) {
   Toast.makeText(context, "onFail()", toast.LENGTH_SHORT).show();
            }
        }).execute();

Netzwerkaufruf von einer asynchronen Aufgabe

public class CheckNetworkConnection extends AsyncTask<Void, Void, Boolean> {
private OnConnectionCallback onConnectionCallback;
private Context context;

public CheckNetworkConnection(Context con, OnConnectionCallback onConnectionCallback) {
     super();
     this.onConnectionCallback = onConnectionCallback;
    this.context = con;
}

@Override
protected void onPreExecute() {
    super.onPreExecute();
}

@Override
protected Boolean doInBackground(Void... params) {
    if (context == null)
        return false;

    boolean isConnected = new NetWorkInfoUtility().isNetWorkAvailableNow(context);
    return isConnected;
}

@Override
protected void onPostExecute(Boolean b) {
    super.onPostExecute(b);

    if (b) {
        onConnectionCallback.onConnectionSuccess();
    } else {
        String msg = "No Internet Connection";
        if (context == null)
            msg = "Context is null";
        onConnectionCallback.onConnectionFail(msg);
    }

}

public interface OnConnectionCallback {
    void onConnectionSuccess();

    void onConnectionFail(String errorMsg);
}
}

Aktuelle Klasse, die an den Server pingt

class NetWorkInfoUtility {

public boolean isWifiEnable() {
    return isWifiEnable;
}

public void setIsWifiEnable(boolean isWifiEnable) {
    this.isWifiEnable = isWifiEnable;
}

public boolean isMobileNetworkAvailable() {
    return isMobileNetworkAvailable;
}

public void setIsMobileNetworkAvailable(boolean isMobileNetworkAvailable) {
    this.isMobileNetworkAvailable = isMobileNetworkAvailable;
}

private boolean isWifiEnable = false;
private boolean isMobileNetworkAvailable = false;

public boolean isNetWorkAvailableNow(Context context) {
    boolean isNetworkAvailable = false;

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

    setIsWifiEnable(connectivityManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI).isConnected());
    setIsMobileNetworkAvailable(connectivityManager.getNetworkInfo(ConnectivityManager.TYPE_MOBILE).isConnected());

    if (isWifiEnable() || isMobileNetworkAvailable()) {
        /*Sometime wifi is connected but service provider never connected to internet
        so cross check one more time*/
        if (isOnline())
            isNetworkAvailable = true;
    }

    return isNetworkAvailable;
}

public boolean isOnline() {
    /*Just to check Time delay*/
    long t = Calendar.getInstance().getTimeInMillis();

    Runtime runtime = Runtime.getRuntime();
    try {
        /*Pinging to Google server*/
        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();
    } finally {
        long t2 = Calendar.getInstance().getTimeInMillis();
        Log.i("NetWork check Time", (t2 - t) + "");
    }
    return false;
 }
}
8
Lokesh Tiwari

Sie müssen nicht komplex sein. Die einfachste und Rahmenweise ist die Verwendung von ACCESS_NETWORK_STATE Erlaubnis und machen Sie einfach eine verbundene Methode

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.

für mehr Details hier klicken

7
Xar E Ahmer

Verwenden Sie diese Methode:

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

Dies ist die erforderliche Erlaubnis:

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

Versuchen Sie den folgenden Code:

public static boolean isNetworkAvailable(Context context) {
        boolean outcome = false;

        if (context != null) {
            ConnectivityManager cm = (ConnectivityManager) context
                    .getSystemService(Context.CONNECTIVITY_SERVICE);

            NetworkInfo[] networkInfos = cm.getAllNetworkInfo();

            for (NetworkInfo tempNetworkInfo : networkInfos) {


                /**
                 * Can also check if the user is in roaming
                 */
                if (tempNetworkInfo.isConnected()) {
                    outcome = true;
                    break;
                }
            }
        }

        return outcome;
    }
5
public boolean checkInternetConnection(Context context) {
    ConnectivityManager connectivity = (ConnectivityManager) context
        .getSystemService(Context.CONNECTIVITY_SERVICE);
    if (connectivity == null) {
        return false;
    } else {
        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;
}
3
Ashish Saini

im Manifest

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

in Code,

public static boolean isOnline(Context ctx) {
    if (ctx == null)
        return false;

    ConnectivityManager cm =
            (ConnectivityManager) ctx.getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo netInfo = cm.getActiveNetworkInfo();
    if (netInfo != null && netInfo.isConnectedOrConnecting()) {
        return true;
    }
    return false;
}
3
R00We

Verwenden Sie diesen Code, um die Internetverbindung zu überprüfen

ConnectivityManager connectivityManager = (ConnectivityManager) ctx
                .getSystemService(Context.CONNECTIVITY_SERVICE);
        if ((connectivityManager
                .getNetworkInfo(ConnectivityManager.TYPE_MOBILE) != null && connectivityManager
                .getNetworkInfo(ConnectivityManager.TYPE_MOBILE).getState() == NetworkInfo.State.CONNECTED)
                || (connectivityManager
                        .getNetworkInfo(ConnectivityManager.TYPE_WIFI) != null && connectivityManager
                        .getNetworkInfo(ConnectivityManager.TYPE_WIFI)
                        .getState() == NetworkInfo.State.CONNECTED)) {
            return true;
        } else {
            return false;
        }
2
Fahim

Nach der "return" -Anweisung können Sie keinen Code schreiben (außer try-finally-Block). Verschieben Sie Ihre neuen Aktivitätscodes vor den "return" -Anweisungen.

2
Burhan ARAS

Hier ist eine Funktion, die ich als Teil meiner Klasse Utils benutze:

public static boolean isNetworkConnected(Context context) {
    ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    return (cm.getActiveNetworkInfo() != null) && cm.getActiveNetworkInfo().isConnectedOrConnecting();
}

Benutze es wie folgt: Utils.isNetworkConnected(MainActivity.this);

1
Mahendra Liya

Dies ist die andere Option, um alle Situationen zu bewältigen:

public void isNetworkAvailable() {
    ConnectivityManager connectivityManager = (ConnectivityManager) ctx.getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
    if (activeNetworkInfo != null && activeNetworkInfo.isConnected()) {
    } else {
        Toast.makeText(ctx, "Internet Connection Is Required", Toast.LENGTH_LONG).show();

    }
}
1
Zafer Celaloglu

Ich hatte Probleme mit der IsInternetAvailable-Antwort, die nicht für Mobilfunknetze getestet wurde, sondern nur, wenn eine WLAN-Verbindung bestand. Diese Antwort funktioniert sowohl für WLAN- als auch für mobile Daten:

Wie überprüfe ich, ob die Netzwerkverbindung in WIFI und 3G (Datentarif) in Mobilgeräten aktiviert oder deaktiviert ist?

1
RedPanda

1- Neue Java Datei erstellen (mit der rechten Maustaste auf das Paket klicken. Neu> Klasse> Datei benennen ConnectionDetector.Java

2- Fügen Sie der Datei den folgenden Code hinzu

package <add you package name> example com.example.example;

import Android.content.Context;
import Android.net.ConnectivityManager;

public class ConnectionDetector {

    private Context mContext;

    public ConnectionDetector(Context context){
        this.mContext = context;
    }

    public boolean isConnectingToInternet(){

        ConnectivityManager cm = (ConnectivityManager)mContext.getSystemService(Context.CONNECTIVITY_SERVICE);
        if(cm.getActiveNetworkInfo() != null && cm.getActiveNetworkInfo().isConnected() == true)
        {
            return true; 
        }

        return false;

    }
}

3- öffne dein MainActivity.Java - die Aktivität, bei der Sie die Verbindung überprüfen möchten, und führen Sie die folgenden Schritte aus

A- Funktion erstellen und definieren.

ConnectionDetector mConnectionDetector;</pre>

B- Fügen Sie in "OnCreate" Folgendes hinzu

mConnectionDetector = new ConnectionDetector(getApplicationContext());

c- Gehen Sie wie folgt vor, um die Verbindung zu überprüfen

if (mConnectionDetector.isConnectingToInternet() == false) {
//no connection- do something
} else {
//there is connection
}
1
Bahi Hussein

Überprüfen Sie das verfügbare Netzwerk in Android mit Internet-Datengeschwindigkeit.

public boolean isConnectingToInternet(){
        ConnectivityManager connectivity = (ConnectivityManager) Login_Page.this.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)
                      {
                          try
                            {
                                HttpURLConnection urlc = (HttpURLConnection) (new URL("http://www.google.com").openConnection());
                                urlc.setRequestProperty("User-Agent", "Test");
                                urlc.setRequestProperty("Connection", "close");
                                urlc.setConnectTimeout(500); //choose your own timeframe
                                urlc.setReadTimeout(500); //choose your own timeframe
                                urlc.connect();
                                int networkcode2 = urlc.getResponseCode();
                                return (urlc.getResponseCode() == 200);
                            } catch (IOException e)
                            {
                                return (false);  //connectivity exists, but no internet.
                            }
                      }

          }
          return false;
    }

Diese Funktion gibt true oder false zurück. Muss Benutzererlaubnis bekommen

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