Vérifier la connexion Internet active Android

Je suis en train d'écrire une partie de mon application qui fera la différence entre un Actif de connexion Wifi et une connexion à internet. Rechercher s'il existe une active la connexion Wifi est assez simple en utilisant le gestionnaire de connexions cependant à chaque fois que j'essaie de tester si je peux me connecter à un site web lorsque le Wifi est connecté, mais il n'y a pas de connexion internet, je me retrouve dans une boucle infinie.
J'ai essayé de pinger google cependant, 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 isReachable de travail.

source d'informationauteur user1528944

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

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

Il vient d'un autre stackoverflow réponse, mais je ne le trouve pas.

EDIT:

Finalement j'ai trouvé: https://stackoverflow.com/a/1565243/2198638

Voici quelques modernes code qui utilise un AsynTask pour contourner un problème où les android se bloque lorsque vous tentez de vous connecter sur le thread principal et introduit une alerte avec un rincez et répétez l'option 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();

Pour vérifier si l'appareil android est d'avoir une connexion active, j'utilise ce hasActiveInternetConnection() la méthode 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;
}
}

Requête d'un site comme celui-ci:

Faire de votre classe en œuvre AsyncTaskCompleteListenere<Boolean> en ajoutant la méthode suivante à la classe:

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

Ajouter un simple testConnection méthode de votre classe à appeler lorsque vous voulez 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 URLExistAsyncTask classe qui effectuer le test de connectivité comme un asynchrone (arrière-plan) de la tâche et des appels de votre onTaskComplete méthode une fois fait:

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

-1

J'ai fait d'utiliser cette méthode. Il a travaillé pour moi! Pour les personnes qui veulent obtenir de l'Internet réel!

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é!

Vous devez vous connecter pour publier un commentaire.