wake-up-neo.com

Überprüfen Sie die aktive Internetverbindung für Android

Ich versuche, einen Teil in meine App zu schreiben, der zwischen einer aktiven WLAN-Verbindung und einer tatsächlichen Verbindung zum Internet unterscheidet. Mit dem Verbindungsmanager ist es ziemlich einfach herauszufinden, ob eine aktive WLAN-Verbindung besteht. Jedes Mal, wenn ich versuche, zu testen, ob ich eine Verbindung zu einer Website herstellen kann, während die WLAN-Verbindung besteht, gerate ich in eine Endlosschleife.
Ich habe versucht, Google anzupingen, aber dies endet auf die gleiche Weise:

Process p1 = Java.lang.Runtime.getRuntime().exec("ping -c 1 www.google.com");
int returnVal = 5;
try {
    returnVal = p1.waitFor();
} catch (InterruptedException e) {
    e.printStackTrace();
}
boolean reachable = (returnVal==0);
return reachable;

Ich habe auch diesen Code ausprobiert:

if (InetAddress.getByName("www.xy.com").isReachable(timeout))
{    }
else
{    }

aber ich konnte es nicht erreichen, um zu arbeiten.

12
user1528944

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

Ich benutze das:

public static void isNetworkAvailable(Context context){
    HttpGet httpGet = new HttpGet("http://www.google.com");
    HttpParams httpParameters = new BasicHttpParams();
    // Set the timeout in milliseconds until a connection is established.
    // The default value is zero, that means the timeout is not used.
    int timeoutConnection = 3000;
    HttpConnectionParams.setConnectionTimeout(httpParameters, timeoutConnection);
    // Set the default socket timeout (SO_TIMEOUT)
    // in milliseconds which is the timeout for waiting for data.
    int timeoutSocket = 5000;
    HttpConnectionParams.setSoTimeout(httpParameters, timeoutSocket);

    DefaultHttpClient httpClient = new DefaultHttpClient(httpParameters);
    try{
        Log.d(TAG, "Checking network connection...");
        httpClient.execute(httpGet);
        Log.d(TAG, "Connection OK");
        return;
    }
    catch(ClientProtocolException e){
        e.printStackTrace();
    }
    catch(IOException e){
        e.printStackTrace();
    }

    Log.d(TAG, "Connection unavailable");
}

Es kommt von einer anderen Stackoverflow-Antwort, aber ich kann es nicht finden.

BEARBEITEN:

Endlich habe ich es gefunden: https://stackoverflow.com/a/1565243/2198638

10
Brtle

Hier ist ein moderner Code, der eine AsynTask verwendet, um ein Problem zu umgehen, bei dem Android abstürzt, wenn Sie versuchen, eine Verbindung zum Haupt-Thread herzustellen, und eine Warnung mit einer Spül- und Wiederholungsoption 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();
3

Um zu überprüfen, ob das Android-Gerät über eine aktive Verbindung verfügt, verwende ich die Methode hasActiveInternetConnection (), mit der (1) ermittelt wird, ob ein Netzwerk verfügbar ist, und (2) anschließend eine Verbindung zu google.com hergestellt wird, um festzustellen, ob das Netzwerk aktiv ist.

public static boolean hasActiveInternetConnection(Context context) {
    if (isNetworkAvailable(context)) {
        if (connectGoogle()) {
            return true;
        } else { //one more try
            return connectGoogle();
        }   
    } else {
        log("No network available! (in hasActiveInternetConnection())");
        return false;
    }
}


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


public static boolean connectGoogle() {
    try {
        HttpURLConnection urlc = (HttpURLConnection)(new URL("http://www.google.com").openConnection());
        urlc.setRequestProperty("User-Agent", "Test");
        urlc.setRequestProperty("Connection", "close");
        urlc.setConnectTimeout(10000); 
        urlc.connect();
        return (urlc.getResponseCode() == 200);     
    } catch (IOException e) {
        log("IOException in connectGoogle())");
        return false;
    }
}
3
sreejin

Fragen Sie eine Website wie diese ab:

Lassen Sie Ihre Klasse AsyncTaskCompleteListenere<Boolean> implementieren, indem Sie Ihrer Klasse die folgende Methode hinzufügen:

@Override
public void onTaskComplete(Boolean result) {
    Toast.makeText(getApplicationContext(), "URL Exist:" + result, Toast.LENGTH_LONG).show();
   // continue your job
}

Fügen Sie Ihrer Klasse eine einfache testConnection-Methode hinzu, die aufgerufen werden soll, wenn Sie die Konnektivität überprüfen möchten:

public void testConnection() {
        URLExistAsyncTask task = new URLExistAsyncTask(this);
        String URL = "http://www.google.com";
        task.execute(new String[]{URL});
    }

Und schließlich die Klasse URLExistAsyncTask, die den Konnektivitätstest als asynchrone (Hintergrund-) Aufgabe ausführt und anschließend die Methode onTaskComplete zurückruft:

  public class URLExistAsyncTask extends AsyncTask<String, Void, Boolean> {
        AsyncTaskCompleteListenere<Boolean> callback;

        public URLExistAsyncTask(AsyncTaskCompleteListenere<Boolean> callback) {
            this.callback = callback;
        }

        protected Boolean doInBackground(String... params) {
            int code = 0;
            try {
                URL u = new URL(params[0]);
                HttpURLConnection huc = (HttpURLConnection) u.openConnection();
                huc.setRequestMethod("GET");
                huc.connect();
                code = huc.getResponseCode();
            } catch (IOException e) {
                return false;
            } catch (Exception e) {
                return false;
            }

            return code == 200;
        }

        protected void onPostExecute(Boolean result){
              callback.onTaskComplete(result);
        }
    }
2
Mohsen Afshin

Ich habe diese Methode verwendet. Es hat bei mir funktioniert! Für Leute, die das echte Internet haben wollen!

public boolean isOnline() {
    try {
        HttpURLConnection httpURLConnection = (HttpURLConnection)(new URL("http://www.google.com").openConnection());
        httpURLConnection.setRequestProperty("User-Agent", "Test");
        httpURLConnection.setRequestProperty("Connection", "close");
        httpURLConnection.setConnectTimeout(10000);
        httpURLConnection.connect();
        return (httpURLConnection.getResponseCode() == 200);
    } catch (IOException e) {
        e.printStackTrace();
        return false;
    }
}

Für diese Methode jedes Mal! Verwenden Sie einfach einen Empfänger und =>

httpURLConnection.getResponseCode() == 200 

Dies bedeutet, dass das Internet verbunden ist!

0
Hadi Note

Sie können dies tun, indem Sie new parallel thread Erstellen, das die Zeit zählt:

final class QueryClass {
    private int responseCode = -1;
     private   String makeHttpRequest(URL url) throws IOException {
            String jsonResponse = "";
            if(url == null) {
                return null;
            }

            HttpURLConnection  urlConnection = null;
            InputStream inputStream = null;
            try {
                urlConnection = (HttpURLConnection) url.openConnection();
                urlConnection.setRequestMethod("GET");
                urlConnection.setReadTimeout(5000 );
                urlConnection.setConnectTimeout(5000 );
                Thread thread = new Thread() {
                    @Override
                    public void run() {
                        super.run();
                        try {
                            sleep(5000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        if(responseCode == -1) {
                            //Perform error message
                        Intent intent = new Intent(context,ErrorsActivity.class);
                        intent.putExtra("errorTextMessage",R.string.errorNoInternet);
                        intent.putExtra("errorImage",R.drawable.no_wifi);
                        context.startActivity(intent);
                        }
                    }
                };
                thread.start();
                urlConnection.connect();
                 responseCode = urlConnection.getResponseCode();
                if (responseCode == 200) {
                    inputStream = urlConnection.getInputStream();
                    jsonResponse = readFromStream(inputStream);

                }
0
Ahmed KHABER