web-dev-qa-db-fra.com

Vérifier la connexion Internet active Android

J'essaie d'écrire dans mon application une partie qui différenciera une connexion Wifi active d'une connexion réelle à Internet. Il est assez simple de savoir s’il existe une connexion Wi-Fi active à l’aide du gestionnaire de connexions, mais chaque fois que j’essaie de vérifier si je peux me connecter à un site Web alors que le Wifi est connecté mais qu’il n’ya pas de connexion Internet, je me retrouve dans une boucle infinie.
J'ai essayé de cingler Google, mais cela se termine de la même façon:

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;

J'ai aussi essayé ce code:

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

mais je ne pouvais pas obtenir est accessible au travail.

javaandroidnetworkingwifiping
12
user1528944

Cela fonctionne pour moi:

Pour vérifier la disponibilité du réseau:

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

Pour vérifier l'accès Internet:

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

J'utilise ceci:

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

Cela provient d'une autre réponse de stackoverflow mais je ne le trouve pas.

MODIFIER:

Enfin je l'ai trouvé: https://stackoverflow.com/a/1565243/2198638

10
Brtle

Voici un code moderne qui utilise une AsynTask pour résoudre un problème où Android se bloque lorsque vous essayez de vous connecter au fil principal et introduit une alerte avec une option de rinçage et de répétition pour l'utilisateur.

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
jenson-button-event

Pour vérifier si le périphérique Android a une connexion active, j'utilise cette méthode hasActiveInternetConnection () ci-dessous. (1) tente de détecter si le réseau est disponible et (2) puis connectez-vous à google.com pour déterminer si le réseau est actif.

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

Interrogez un site Web comme celui-ci:

Faites que votre classe implémente AsyncTaskCompleteListenere<Boolean> en ajoutant la méthode suivante à votre classe:

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

Ajoutez une méthode testConnection simple à votre classe à appeler lorsque vous souhaitez vérifier votre connectivité:

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

Et enfin, la classe URLExistAsyncTask qui effectue le test de connectivité en tant que tâche asynchrone (en arrière-plan) et rappelle votre méthode onTaskComplete une fois qu'elle est effectuée:

  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

J'ai utilisé cette méthode. Cela a fonctionné pour moi! Pour les personnes qui veulent avoir le vrai Internet!

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

Pour faire cette méthode à chaque fois! Il suffit d'utiliser un récepteur et =>

httpURLConnection.getResponseCode() == 200

Cela signifie que l'Internet est connecté!

0
Hadi Note