Comment vérifier l'accès à internet sur Android? InetAddress n'arrive jamais à expiration

Connexion réseau /accès Internet

• isConnectedOrConnecting() (utilisé dans la plupart des réponses) vérifie pour tout réseau connexion
• Savoir si l'un de ces réseaux ont internet d'accès, utilisez l'une des opérations suivantes

Un Ping d'un Serveur (facile)

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

+ pourrait exécuter sur le thread principal

- ne fonctionne pas sur certains appareils anciens (Galays S3, etc.), il bloque, si l'internet n'est disponible.

B) pour la connexion à un Socket sur Internet (avancé)

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

+ très rapide (de toute façon), fonctionne sur tous les appareils, très fiable

- ne peut pas s'exécuter sur le thread de l'INTERFACE utilisateur

Cela fonctionne de manière très fiable, sur tous les appareils, et est très rapide. Qu'il doit exécuter dans un autre bien que la tâche (p. ex. ScheduledExecutorService ou AsyncTask).

Questions Possibles

• Est-il vraiment assez rapide?

  Oui, très vite 😉

• Est-il pas de moyen fiable de vérifier l'internet, d'autres à faire que de tester quelque chose sur internet?

  Pas pour autant que je sais, mais laissez-moi savoir, et je vais éditer ma réponse.

• Que si le serveur est en panne?

  Google DNS (par exemple,8.8.8.8) est le plus grand public DNS dans le monde. En 2013, il a servi à 130 milliards de requêtes par jour. Laissez 's juste de dire, votre application ne serait probablement pas être le sujet de conversation du jour.

• Quelles autorisations sont nécessaires?

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

  Un simple accès à internet - surprise ^^ (d'ailleurs avez-vous jamais pensé, comment certaines des méthodes proposées ici pourraient même avoir une télécommande de la colle sur l'accès à internet, sans cette autorisation?)

 

Supplémentaire: One-shot AsyncTask Exemple

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

Supplémentaire: One-shot RxJava/RxAndroid Exemple (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 */}

Pas besoin d'être complexe. Le plus simple et le cadre façon est d'utiliser ACCESS_NETWORK_STATE autorisation et juste faire un connecté méthode

public boolean isOnline() {
    ConnectivityManager cm =
        (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);

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

Vous pouvez également utiliser requestRouteToHost si vous avez un particulier de l'hôte et le type de connexion (wifi/mobile) dans l'esprit.

Vous aurez également besoin de:

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

dans votre manifeste android.

vérifier ce code... cela a fonctionné pour moi 🙂

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

Puis-je définir le gestionnaire d':

Handler h = new Handler() {
    @Override
    public void handleMessage(Message msg) {

        if (msg.what != 1) { //code if not connected

        } else { //code if connected

        }   
    }
};

...et lancer le test:

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

Trouvé et modifié (!) à partir de ce lien :

Dans votre fichier de manifeste d'ajouter au moins:

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

Vous avez probablement déjà l'INTERNET permission si vous y accédez. Ensuite, une fonction booléenne qui permet de tester la connectivité est:

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

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

De tout ce que j'ai vu jusqu'à présent la plus courte et la meilleure façon devrait être:

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: Ce n'est pas exécutée sur n'importe quel hôte, il vérifie juste la connectionstatus, donc si votre routeur n'a pas de connexion internet et que votre appareil est connecté à cette méthode retourne vrai bien que vous n'avez pas internet.

Pour un test, je recommanderais execuding un HttpHead demande (p. ex. http://www.google.com) et de vérifier l'état, si son 200 OK tout va bien et que votre appareil dispose d'une connexion internet.

Un important cas d'utilisation sur des appareils mobiles afin de garantir une connexion existe. C'est un problème courant lors d'un mobile utilisateur entre un réseau Wifi avec un "Portail Captif", dans laquelle ils ont besoin de se connecter. J'utilise cette fonction de blocage à l'arrière-plan afin d'assurer une connexion existe.

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

Pour moi, c'était pas une bonne pratique pour vérifier l'état de la connexion dans l'Activité de classe, parce que

ConnectivityManager cm =
(ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);

devrait être appelé là-bas, ou vous avez besoin de pousser vers le bas de votre Activité instance (contexte) pour le gestionnaire de connexion de la classe afin de pouvoir vérifier l'état de la connexion, il y
Lorsqu'aucune connexion disponible (wifi, réseau), j'ai attraper le UnknownHostException exception:

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

De cette façon, je peux gérer ce cas avec les autres cas de la même classe (mon serveur toujours la réponse de retour avec une chaîne json)

Im en utilisant ce code à la place de la 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();
}

Meilleure approche:

public static boolean isOnline() {
try {
InetAddress.getByName("google.com").isReachable(3);
return true;
} catch (UnknownHostException e){
return false;
} catch (IOException e){
return false;
}
}

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

J'ai appliqué la solution proposée par @Levit et créé fonction qui n'ira pas en appel de la Requête Http.

Il permettra de résoudre l'erreur Unable to Resolve Host

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

Maintenant l'appeler comme,

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

Cette méthode vous donne la possibilité de vraiment une méthode rapide (pour des commentaires en temps réel) ou une méthode plus lente (pour un arrêt des contrôles qui nécessitent de la fiabilité)

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

Je suis passé par toutes les réponses et je viens avec ma propre réponse, qui d'abord vérifier si Internet est disponible et si Internet est disponible, alors il vérifier si il est actif ou pas.

J'ai inclus tout le nécessaire de la méthode et des classes pour vérifier la connexion Internet active.

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

Vous pouvez vérifier si Internet est active à l'aide de code ci-dessous:

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

Il suffit de créer la classe suivante qui vérifie pour une connexion internet:

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

Cette classe contient une méthode qui retourne la valeur booléenne de l'état de la connexion. Donc, en termes simples, si la méthode trouve une connexion Internet, la valeur de retour est true, sinon false si pas de connexion valide est trouvé.

La méthode suivante dans le MainActivity appelle ensuite le résultat de la méthode décrite précédemment, et invite l'utilisateur à agir en conséquence:

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

Dans le code ci-dessus, si le résultat est faux, (donc il n'y a pas de connexion internet, l'utilisateur est pris pour le wi-fi Android panneau, où il est invité à se connecter à un hotspot wi-fi.

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

J'ai fait de cette manière.
Un peu plus court et plus lisible, je suppose.

Cheers!

Saiyan

C'est tellement génial d'avoir plus d'une manière de coder.
Voici mon exemple.

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

Bonne chance.

Ce code va vous aider à trouver l'internet est en marche ou pas.

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

Aussi, vous devez fournir les autorisations suivantes

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

Si vous avez besoin de vérifier pour la connexion internet, utilisation de cette méthode à l'aide de la commande ping sur le serveur:

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

Soit vous pouvez utiliser la vérifier à l'aide du port

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

La plus solution la plus Simple serait de

Dans la plupart des cas, il pourra vérifier la connexion internet si il/elle veut se connecter au serveur distant afin de les simple et la meilleure solution serait de requête ping de votre serveur comme suit.

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

N'oubliez pas d'ajouter ce autorisations à votre manifeste :

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

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

Ici est l'autorisation que vous avez besoin de :

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

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