web-dev-qa-db-fra.com

Comment vérifier l'accès Internet sur Android? InetAddress n'expire jamais

J'ai un AsyncTask censé vérifier l'accès réseau à un nom d'hôte. Mais la doInBackground() n'est jamais arrivée à expiration. Quelqu'un a un indice?

public class HostAvailabilityTask extends AsyncTask<String, Void, Boolean> {

    private Main main;

    public HostAvailabilityTask(Main main) {
        this.main = main;
    }

    protected Boolean doInBackground(String... params) {
        Main.Log("doInBackground() isHostAvailable():"+params[0]);

        try {
            return InetAddress.getByName(params[0]).isReachable(30); 
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return false;       
    }

    protected void onPostExecute(Boolean... result) {
        Main.Log("onPostExecute()");

        if(result[0] == false) {
            main.setContentView(R.layout.splash);
            return;
        }

        main.continueAfterHostCheck();
    }   
}
625
Vidar Vestnes

Connexion réseau/accès Internet

  • isConnectedOrConnecting() (utilisé dans la plupart des réponses) vérifie toute connexion résea
  • Pour savoir si l’un de ces réseaux a un accès Internet, utilisez l’un des logiciels suivants:

A) Cingler 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 fonctionner sur le thread principal

- ne fonctionne pas sur certains anciens appareils (Galays S3, etc.), il bloque pendant un certain temps si aucun Internet n'est disponible.

B) Connexion à une prise 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 (dans tous les cas), fonctionne sur tous les appareils, très fiable

- ne peut pas s'exécuter sur le thread d'interface utilisateur

Cela fonctionne de manière très fiable sur tous les appareils et est très rapide. Il doit cependant être exécuté dans une tâche distincte (par exemple, ScheduledExecutorService ou AsyncTask).

Questions possibles

  • Est-ce vraiment assez rapide?

    Oui, très vite; -)

  • N'y a-t-il aucun moyen fiable de vérifier Internet, mis à part tester quelque chose sur Internet?

    Pas autant que je sache, mais faites-le-moi savoir et je modifierai ma réponse.

  • Et si le DNS est en panne?

    Google DNS (par exemple, 8.8.8.8) est le plus grand DNS public au monde. En 2013, 130 milliards de demandes par jour étaient traitées. Disons simplement que votre application ne serait probablement pas le sujet du jour.

  • Quelles sont les autorisations nécessaires?

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

    Juste un accès Internet - surprise ^^ (Au fait, y avez-vous déjà pensé, comment certaines des méthodes suggérées ici pourraient même avoir un lien distant avec l'accès Internet, sans cette permission?)

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

Extra: 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 */}
492
Levit

Si l'appareil est en mode avion (ou vraisemblablement dans d'autres situations où il n'y a pas de réseau disponible), cm.getActiveNetworkInfo() sera null, vous devez donc ajouter une vérification null.

Modifié ( solution d'Eddie ) ci-dessous:

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

Ajoutez également l'autorisation suivante au AndroidManifest.xml:

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

Un autre petit point, si vous avez absolument besoin d’une connexion réseau à un moment donné, il peut être préférable d’utiliser netInfo.isConnected() plutôt que netInfo.isConnectedOrConnecting. Je suppose que cela dépend toutefois du cas d'utilisation individuel.

1022
gar

Pas besoin d'être complexe. La méthode la plus simple et la plus simple consiste à utiliser la permission ACCESS_NETWORK_STATE et à créer une méthode connectée

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 à l’esprit un hôte particulier et un type de connexion (wifi/mobile).

Vous aurez également besoin de:

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

dans votre manifeste Android.

293
Eddie

Pour que getActiveNetworkInfo() fonctionne, vous devez ajouter ce qui suit au manifeste.

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

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

Ensuite, je définis le gestionnaire:

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

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

        } else { // code if connected

        }   
    }
};

... et lancez le test:

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

Jetez un coup d'œil à la classe ConnectivityManager. Vous pouvez utiliser cette classe pour obtenir des informations sur les connexions actives sur un hôte. http://developer.Android.com/reference/Android/net/ConnectivityManager.html

EDIT: Vous pouvez utiliser

Context.getSystemService(Context.CONNECTIVITY_SERVICE)
    .getNetworkInfo(ConnectivityManager.TYPE_MOBILE) 

ou

Context.getSystemService(Context.CONNECTIVITY_SERVICE)
    .getNetworkInfo(ConnectivityManager.TYPE_WIFI) 

et analyser l'énumération DetailedState de l'objet NetworkInfo renvoyé

EDIT EDIT: pour savoir si vous pouvez accéder à un hôte, vous pouvez utiliser

Context.getSystemService(Context.CONNECTIVITY_SERVICE)
    .requestRouteToHost(TYPE_WIFI, int hostAddress)

Évidemment, j'utilise Context.getSystemService (Context.CONNECTIVITY_SERVICE) comme proxy pour dire

ConnectivityManager cm = Context.getSystemService(Context.CONNECTIVITY_SERVICE);
cm.yourMethodCallHere();
45
Chinmay Kanchi

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

Dans votre fichier manifeste, ajoutez au moins:

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

Vous avez probablement déjà l'autorisation INTERNET si vous y accédez. Ensuite, une fonction booléenne permettant 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;
    }
}
26
Ajhar

J'ai fait ce code, c'est le plus simple et ce n'est qu'un booléen. en demandant if(isOnline()){

Vous obtenez s'il y a une connexion et si elle peut se connecter à une page le code d'état 200 (connexion stable).

Assurez-vous d’ajouter les autorisations INTERNET et ACCESS_NETWORK_STATE correctes.

public boolean isOnline() {
    ConnectivityManager cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo netInfo = cm.getActiveNetworkInfo();
    if (netInfo != null && netInfo.isConnected()) {
        try {
            URL url = new URL("http://www.google.com");
            HttpURLConnection urlc = (HttpURLConnection) url.openConnection();
            urlc.setConnectTimeout(3000);
            urlc.connect();
            if (urlc.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();
        }
    }
    return false;
}
15
Android.Thirio.nl

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

Il y a plus d'un moyen

D'abord, le plus court mais le plus inefficace

Permission d'état du réseau seulement nécessaire

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

Puis cette méthode,

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

        NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
        boolean isConnected = activeNetwork != null &&
                activeNetwork.isConnected();

        return isConnected;

    }

Comme on le voit dans les réponses, ConnectivityManager est une solution, je viens de l'ajouter à une méthode. Il s'agit d'une méthode simplifiée à utiliser
ConnectivityManager renvoie true s'il existe un accès réseau, pas d'accès Internet, signifie que si votre réseau WiFi est connecté à un routeur mais que le routeur ne dispose pas d'internet, il renvoie true, il vérifie la disponibilité de la connexion

Deuxièmement, manière efficace

Etat du réseau et autorisations Internet nécessaires

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

Puis cette classe,

 public class CheckInternetAsyncTask extends AsyncTask<Void, Integer, Boolean> {

        private Context context;

        public CheckInternetAsyncTask(Context context) {
            this.context = context;
        }

        @Override
        protected Boolean doInBackground(Void... params) {

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

            assert cm != null;
            NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
            boolean isConnected = activeNetwork != null &&
                    activeNetwork.isConnected();


            if (isConnected) {
                try {
                    HttpURLConnection urlc = (HttpURLConnection)
                            (new URL("http://clients3.google.com/generate_204")
                                    .openConnection());
                    urlc.setRequestProperty("User-Agent", "Android");
                    urlc.setRequestProperty("Connection", "close");
                    urlc.setConnectTimeout(1500);
                    urlc.connect();
                    if (urlc.getResponseCode() == 204 &&
                            urlc.getContentLength() == 0)
                        return true;

                } catch (IOException e) {
                    Log.e("TAG", "Error checking internet connection", e);
                    return false;
                }
            } else {
                Log.d("TAG", "No network available!");
                return false;
            }


            return null;
        }

        @Override
        protected void onPostExecute(Boolean result) {
            super.onPostExecute(result);
            Log.d("TAG", "result" + result);

            if(result){
                // do ur code
            }

        }


    }

Appeler CheckInternetAsyncTask

new CheckInternetAsyncTask(getApplicationContext()).execute();

Quelques explications: -

  • vous devez vérifier Internet sur AsyncTask, sinon il peut jeter Android.os.NetworkOnMainThreadException dans certains cas

  • ConnectivityManager utilisé pour vérifier l'accès au réseau si la demande d'envoi est vraie (Ping)

  • Demande d'envoi à http://clients3.google.com/generate_204, Cette URL bien connue est connue pour renvoyer une page vide de statut HTTP 204, ce qui est plus rapide et plus efficace que http://www.google.com, lisez this . si vous avez un site Web, il est préférable de mettre votre site Web à la place de Google, uniquement si vous l'utilisez dans l'application.

  • Le délai peut être modifié (20 ms -> 2000 ms), 1500 ms est couramment utilisé

9
Mohamed Embaby

De tout ce que j'ai vu jusqu'ici, le chemin le plus court et le plus propre 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: Cela ne cingle aucun hôte, il vérifie simplement l’état de la connexion. Ainsi, si votre routeur n’a pas de connexion Internet et que votre appareil y est connecté, cette méthode renverra true bien que vous n’ayez pas Internet.
Pour un test réel, je vous recommande d’exécuter une requête HttpHead (par exemple, sur www.google.com) et de vérifier le statut, le cas échéant. 200 OK tout va bien et votre appareil dispose d'une connexion Internet.

8
Nickolaus

Voici la méthode que j'utilise:

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

Encore mieux, assurez-vous qu'il est "connecté":

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

Voici comment utiliser la méthode:

if (isNetworkAvailable(context)) {
    // code here
} else {
    // code
}

Permission nécessaire:

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

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

8
Jared Burrows

Un cas d'utilisation important sur les appareils mobiles consiste à s'assurer qu'une connexion réelle existe. Il s'agit d'un problème courant lorsqu'un utilisateur mobile entre dans un réseau Wi-Fi avec un "portail captif", sur lequel il doit se connecter. J'utilise cette fonction de blocage en arrière-plan pour garantir l'existence d'une connexion.

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

Vous pouvez parcourir toutes les connexions réseau et vérifier s'il existe au moins une connexion disponible:

public boolean isConnected() {
    boolean connected = false;

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

    if (cm != null) {
        NetworkInfo[] netInfo = cm.getAllNetworkInfo();

        for (NetworkInfo ni : netInfo) {
            if ((ni.getTypeName().equalsIgnoreCase("WIFI")
                    || ni.getTypeName().equalsIgnoreCase("MOBILE"))
                    && ni.isConnected() && ni.isAvailable()) {
                connected = true;
            }

        }
    }

    return connected;
}
6
Emre Yazici

Cela fonctionne pour moi. Essaye le.

public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
    try {
        URL url = new URL("http://stackoverflow.com/posts/11642475/edit" );
        //URL url = new URL("http://www.nofoundwebsite.com/" );
        executeReq(url);
        Toast.makeText(getApplicationContext(), "Webpage is available!", Toast.LENGTH_SHORT).show();
    }
    catch(Exception e) {
        Toast.makeText(getApplicationContext(), "oops! webpage is not available!", Toast.LENGTH_SHORT).show();
    }
}

private void executeReq(URL urlObject) throws IOException
{
    HttpURLConnection conn = null;
    conn = (HttpURLConnection) urlObject.openConnection();
    conn.setReadTimeout(30000);//milliseconds
    conn.setConnectTimeout(3500);//milliseconds
    conn.setRequestMethod("GET");
    conn.setDoInput(true);

    // Start connect
    conn.connect();
    InputStream response =conn.getInputStream();
    Log.d("Response:", response.toString());
}}
6
selva_pollachi

Pour moi, ce n’était pas une bonne pratique de vérifier l’état de la connexion dans la classe d’activité, car

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

devrait être appelé ici, ou vous devez pousser votre instance d'activité (contexte) vers la classe du gestionnaire de connexion pour pouvoir vérifier l'état de la connexion là-bas. Lorsqu'aucune connexion disponible (wifi, réseau) je récupère le nknownHostException 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 répond toujours avec une chaîne json)

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

}
5
user2912903

Il n’est pas complexe de vérifier Android l’état de la connectivité réseau/Internet. La classe DetectConnection ci-dessous vous aidera à vérifier ce statut:

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

public class DetectConnection {
    public static boolean checkInternetConnection(Context context) {
        ConnectivityManager con_manager = (ConnectivityManager) context
                                .getSystemService(Context.CONNECTIVITY_SERVICE);

        if (con_manager.getActiveNetworkInfo() != null
            && con_manager.getActiveNetworkInfo().isAvailable()
            && con_manager.getActiveNetworkInfo().isConnected()) {
                return true;
        } else {
            return false;
        }
    }
}

Pour plus de détails, visitez le site Comment vérifier Android État de la connectivité réseau/Internet

5
JSupport

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;
    }
    }
5
Lo Juego

J'ai appliqué la solution fournie par @Levit et créé une fonction qui n'appelle pas la requête HTTP supplémentaire.

Cela résoudra 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, appelle comme ça,

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

En utilisant ce code à la place de 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();
    }
5
Vidar Vestnes

Vous pouvez utiliser cette méthode pour détecter la disponibilité du réseau.

public static boolean isDeviceOnline(Context context) {
        boolean isConnectionAvail = false;
        try {
            ConnectivityManager cm = (ConnectivityManager) context
                    .getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo netInfo = cm.getActiveNetworkInfo();
            return netInfo.isConnected();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return isConnectionAvail;
    }
5
Akshay Paliwal

Cette méthode vous permet d’opter pour une méthode très rapide (pour un retour en temps réel) ou une méthode plus lente (pour des contrôles ponctuels nécessitant une 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;
}
5

Voici le code de ma classe Utils:

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

Très important de vérifier si nous avons une connectivité avec isAvailable () et s'il est possible d'établir une connexion avec isConnected ()

private static ConnectivityManager manager;

public static boolean isOnline(Context context) {
    ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();
    return networkInfo != null && networkInfo.isAvailable() && networkInfo.isConnected();
}

et vous pouvez déterminer le type de réseau actif WiFi :

public static boolean isConnectedWifi(Context context) {
    ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();
    return networkInfo != null && networkInfo.getType() == ConnectivityManager.TYPE_WIFI;
}

ou mobile Móvil :

public static boolean isConnectedMobile(Context context) {
    ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();
    return networkInfo != null && networkInfo.getType() == ConnectivityManager.TYPE_MOBILE;
}

n'oubliez pas les autorisations:

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

Les autres réponses qui utilisent ConnectivityManager sont incorrectes, car une connexion réseau ne signifie pas que vous avez un accès Internet. Par exemple, l'utilisateur peut être connecté au portail WiFi d'un café mais ne peut pas accéder à Internet. Pour vérifier que l’Internet est accessible, vous devez essayer de vous connecter à un serveur réel. Normalement, lorsque vous souhaitez effectuer cette opération, vous souhaitez vous connecter à un serveur spécifique, alors allez-y et vérifiez si vous pouvez vous connecter à ce serveur. Voici une méthode simple pour vérifier la connectivité à un serveur.

private boolean isOnTheInternet() {
    try {
        URLConnection urlConnection = new URL("http://yourserver").openConnection();
        urlConnection.setConnectTimeout(400);
        urlConnection.connect();
        return true;
    } catch (Exception e) {
        return false;
    }
}

La raison pour laquelle vous avez défini ConnectTimeout est qu’autrement, le délai d’attente par défaut est TCP, qui peut durer plusieurs secondes.

Notez également que Android ne vous laissera pas exécuter ceci sur votre thread principal.

4
miguel
4
kreker

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

J'ai inclus toutes les méthodes et classes nécessaires 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 actif en utilisant le 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);
            }
        });
    }
4
Rajesh

Mise à jour du 29/06/2015 Si vous utilisez Xamarin.Android et souhaitez vérifier la connectivité, vous pouvez utiliser un package Nuget qui vous offrirait cette fonctionnalité. sur plusieurs plates-formes. Les bons candidats sont ici et ici . [Fin de mise à jour]

Les réponses ci-dessus sont assez bonnes, mais elles sont toutes en Java et presque toutes vérifient la connectivité. Dans mon cas, je devais avoir une connectivité avec un type spécifique de connexion et je développe sur Xamarin.Android. De plus, je ne passe pas de référence à mon contexte d’activités dans la couche Matériel, j’utilise le contexte d’application. Voici donc ma solution, au cas où quelqu'un viendrait ici avec des exigences similaires. Je n'ai pas encore fait de test complet, je mettrai à jour la réponse une fois mes tests terminés.

using Android.App;
using Android.Content;
using Android.Net;

namespace Leopard.Mobile.Hal.Android
{
    public class AndroidNetworkHelper
    {
        public static AndroidNetworkStatus GetWifiConnectivityStatus()
        {
            return GetConnectivityStatus(ConnectivityType.Wifi);
        }

        public static AndroidNetworkStatus GetMobileConnectivityStatus()
        {
            return GetConnectivityStatus(ConnectivityType.Mobile);
        }

        #region Implementation

        private static AndroidNetworkStatus GetConnectivityStatus(ConnectivityType connectivityType)
        {
            var connectivityManager = (ConnectivityManager)Application.Context.GetSystemService(Context.ConnectivityService);
            var wifiNetworkInfo = connectivityManager.GetNetworkInfo(connectivityType);
            var result = GetNetworkStatus(wifiNetworkInfo);
            return result;
        }

        private static AndroidNetworkStatus GetNetworkStatus(NetworkInfo wifiNetworkInfo)
        {
            var result = AndroidNetworkStatus.Unknown;
            if (wifiNetworkInfo != null)
            {
                if (wifiNetworkInfo.IsAvailable && wifiNetworkInfo.IsConnected)
                {
                    result = AndroidNetworkStatus.Connected;
                }
                else
                {
                    result = AndroidNetworkStatus.Disconnected;
                }
            }
            return result;
        } 

        #endregion
    }

    public enum AndroidNetworkStatus
    {
        Connected,
        Disconnected,
        Unknown
    }
3
Has AlTaiar

Créez simplement la classe suivante qui vérifie 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 simplement une méthode qui renvoie la valeur booléenne du statut de la connexion. Par conséquent, en termes simples, si la méthode trouve une connexion valide à Internet, la valeur de retour est true, sinon false si aucune connexion valide n'est trouvée.

La méthode suivante dans 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 (par conséquent, il n'y a pas de connexion Internet, l'utilisateur est dirigé vers le panneau wi-fi Android, où il est invité à se connecter à un point d'accès Wi-Fi.

3
Michele La Ferla

C'est tellement génial d'avoir plus d'un moyen 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.

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

Je l'ai fait de cette façon. Un peu plus court et plus lisible, je suppose.

À votre santé!

Saiyan

2
InsaurraldeAP

Si vous utilisez l'API 23 ou une version ultérieure, vous pouvez maintenant vérifier si Internet est actif ou non en utilisant NetworkCapabilities.NET_CAPABILITY_VALIDATED , qui est pris en charge par le propre service de ping de Google.

ConnectivityManager.NetworkCallback networkCallback = new ConnectivityManager.NetworkCallback() {
    @Override
    public void onLost(Network network) {
        // handle network lost
    }

    @Override
    public void onAvailable(Network network) {
        ConnectivityManager cm = (ConnectivityManager) getApplicationContext().getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo info = cm.getNetworkInfo(network);
        boolean isConnected = (info != null && info.isConnectedOrConnecting());

        if (isConnected) {
            NetworkCapabilities nc = cm.getNetworkCapabilities(network);
            if (nc != null) {
                boolean isInternetValid = nc.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED);
                if (isInternetValid) {
                    // internet is valid
                }
            }
        }
    }
};

NetworkRequest request = new NetworkRequest.Builder().addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET).build();
ConnectivityManager connectivityManager = (ConnectivityManager) getApplicationContext().getSystemService(Context.CONNECTIVITY_SERVICE);
connectivityManager.registerNetworkCallback(request, networkCallback);
2
Keeeeeenw
public static boolean isNetworkAvailable(Context ctx) {
ConnectivityManager connMgr = (ConnectivityManager)ctx.getSystemService(Context.CONNECTIVITY_SERVICE);
if(connMgr.getNetworkInfo(ConnectivityManager.TYPE_WIFI).isConnected() ||
    connMgr.getNetworkInfo(ConnectivityManager.TYPE_MOBILE).isConnected()){
        return true;
}

return false;
 } 

utiliser cette

2
geekdev786

La solution la plus simple serait

Dans la plupart des cas, on ne vérifie la connexion Internet que s’il souhaite se connecter au serveur distant. La solution la plus simple et la meilleure solution serait donc d’envoyer une requête ping à votre serveur.

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

Ce code vous aidera à trouver que l’Internet est allumé ou non.

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

En outre, vous devez fournir les autorisations suivantes

<uses-permission Android:name="Android.permission.INTERNET" />
<uses-permission Android:name="Android.permission.ACCESS_NETWORK_STATE" />
1
Vishnu M A
 public static boolean isNetworkAvailable(Context context) {
    boolean flag = checkNetworkAvailable(context);

    if (!flag) {
        Log.d("", "No network available!");
    } 
    return flag;
}


private static boolean checkNetworkAvailable(Context context) {
    ConnectivityManager connectivityManager
            = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
    return activeNetworkInfo != null;
}
1
Gautam Surani

Si vous devez vérifier la connexion Internet, utilisez cette méthode en utilisant ping to the server:

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 check through using 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; }
}
1
E J Chathuranga

J'ai essayé avec près de 5+ approches Android différentes et je trouve que c'est la meilleure solution fournie par Google spécialement pour Android:

  try {
  HttpURLConnection urlConnection = (HttpURLConnection)
  (new URL("http://clients3.google.com/generate_204")
  .openConnection());
  urlConnection.setRequestProperty("User-Agent", "Android");
  urlConnection.setRequestProperty("Connection", "close");
  urlConnection.setConnectTimeout(1500);
  urlConnection.connect();
  if (urlConnection.getResponseCode() == 204 &&
  urlConnection.getContentLength() == 0) {
  Log.d("Network Checker", "Successfully connected to internet");
  return true;
  }
  } catch (IOException e) {
  Log.e("Network Checker", "Error checking internet connection", e);
  }

C'est faster, efficient et accurate autre que toute autre solution disponible.

1
0xAliHn
if(isConnected()){
                Toast.makeText(getApplication(),"Thank you",Toast.LENGTH_SHORT).show();
        }
        else{

            AlertDialog.Builder builder =
                    new AlertDialog.Builder(this, R.style.AppCompatAlertDialogStyle);
            builder.setTitle("Amar Bhat");
            builder.setMessage("Oops...You are not connected to Internet!!!");
            builder.setPositiveButton("OK", null);
            builder.setNegativeButton("Cancel", null);
            builder.show();
            //Toast.makeText(getApplication(),"You are not connected",Toast.LENGTH_SHORT).show();
        }




//And outside the class define isConnected()

 public boolean isConnected(){
        ConnectivityManager connMgr = (ConnectivityManager) getSystemService(Activity.CONNECTIVITY_SERVICE);
        NetworkInfo networkInfo = connMgr.getActiveNetworkInfo();
        if (networkInfo != null && networkInfo.isConnected())
            return true;
        else
            return false;
    }

// In minifest add these permission
<uses-permission Android:name="Android.permission.INTERNET" />

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

C'est le moyen le plus simple et le plus facile de vérifier la connexion Internet pour le wifi et les données mobiles.

public static boolean isConnected(Activity _context) {
        if (_context != null) {
            ConnectivityManager connMgr = (ConnectivityManager) _context.getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo activeInfo = connMgr.getActiveNetworkInfo();
            if (activeInfo != null && activeInfo.isConnected()) {
                boolean wifiConnected = activeInfo.getType() == ConnectivityManager.TYPE_WIFI;
                boolean mobileConnected = activeInfo.getType() == ConnectivityManager.TYPE_MOBILE;

                if (wifiConnected || mobileConnected) {
                    Log.d(TAG, "Wifi Connected ");
                    return true;
                } else {
                    showAlert(_context,_context.getString(R.string.err_no_internet));
                    return false;
                }
            } else {
                showAlert(_context,_context.getString(R.string.err_no_internet));
                return false;
            }
        } else {
            Log.e(TAG, "networkConnectivity: Context NULL");

        }
        return false;
    }
0
Faizal Abbas

Voici un code moderne qui utilise un AsynTask pour résoudre un problème où Android se bloque lorsque vous essayez de vous connecter sur le thread 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();
0

Voici la version Kotlin que j'utilise pour vérifier l'accessibilité,

Kotlin MyReachability

object MyReachability {

    private val REACHABILITY_SERVER = "http://google.com" // can be any URL you want

    private fun hasNetworkAvailable(context: Context): Boolean {
        val service = Context.CONNECTIVITY_SERVICE
        val manager = context.getSystemService(service) as ConnectivityManager?
        val network = manager?.activeNetworkInfo
        Log.d(classTag, "hasNetworkAvailable: ${(network != null)}")
        return (network != null)
    }

    fun hasInternetConnected(context: Context): Boolean {
        if (hasNetworkAvailable(context)) {
            try {
                val connection = URL(REACHABILITY_SERVER).openConnection() as HttpURLConnection
                connection.setRequestProperty("User-Agent", "Test")
                connection.setRequestProperty("Connection", "close")
                connection.connectTimeout = 1500
                connection.connect()
                Log.d(classTag, "hasInternetConnected: ${(connection.responseCode == 200)}")
                return (connection.responseCode == 200)
            } catch (e: IOException) {
                Log.e(classTag, "Error checking internet connection", e)
            }
        } else {
            Log.w(classTag, "No network available!")
        }
        Log.d(classTag, "hasInternetConnected: false")
        return false
    }
}

Vous pouvez même passer le REACHABILITY_SERVER en tant que paramètre basé sur la politique et les restrictions. Par exemple, lorsque vous êtes en Chine, vous pouvez vérifier https://baidu.com plutôt https://google.com .

Exemple d'appel,

val webLoaderThread = Thread {
   if (MyReachability.hasInternetConnected(this)){
       runOnUiThread {
           //mWebView.loadUrl(LANDING_SERVER) // connected
       }
   } else {
       runOnUiThread {
           //showDialogNoNetwork() // not connected
       }
   }
}
webLoaderThread.start()

Autorisations Android

N'oubliez pas d'ajouter ces autorisations ci-dessous à votre AndroidManifest.xml

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

Vous pouvez également consulter Internet avec le code ci-dessous:

 public class CheckInternetConnection {
        public Context context = null;

        public CheckInternetConnection(Context ctx) {
            this.context = ctx;
        }

        public boolean CheckInternet() {
            return isOnline();
        }
        public Boolean isOnline() 
        {
            try {
                if(isNetAvailable(context))
                    return true;
                else
                {
                    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(3000); // This is time limit if the
                        // connection time limit
                        try {
                            urlc.connect();
                            Log.e("TAG", " urlc ----------" + urlc.getResponseCode());
                            if (urlc.getResponseCode() == 200) {
                                return true;
                            }
                        }catch (Exception e){
                            e.printStackTrace();
                        }
                    } catch (MalformedURLException e1) {
                        e1.printStackTrace();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }catch (Exception e){
                e.printStackTrace();
            }

            return false;        
        }

         public synchronized static boolean isNetAvailable(Context context){

             try{
             boolean isNetAvailable=false;
             if ( context != null )
             {
                 ConnectivityManager mgr = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
                 if ( mgr != null )
                 {
                     boolean mobileNetwork = false;
                     boolean wifiNetwork = false;
                     boolean wiMaxNetwork = false;

                     boolean mobileNetworkConnecetd = false;
                     boolean wifiNetworkConnecetd = false;
                     boolean wiMaxNetworkConnected = false;

                     NetworkInfo mobileInfo = mgr.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
                     NetworkInfo wifiInfo = mgr.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
                     NetworkInfo wiMaxInfo = mgr.getNetworkInfo(ConnectivityManager.TYPE_WIMAX);

                     if ( mobileInfo != null )
                         mobileNetwork = mobileInfo.isAvailable();                   

                     if ( wifiInfo != null )
                         wifiNetwork = wifiInfo.isAvailable();

                     if(wiMaxInfo != null)
                         wiMaxNetwork = wiMaxInfo.isAvailable();

                     if(wifiNetwork == true)
                         wifiNetworkConnecetd = wifiInfo.isConnectedOrConnecting();
                     if(mobileNetwork == true)
                         mobileNetworkConnecetd = mobileInfo.isConnectedOrConnecting();
                     if(wiMaxNetwork == true)
                         wiMaxNetworkConnected = wiMaxInfo.isConnectedOrConnecting();

                     isNetAvailable = ( mobileNetworkConnecetd || wifiNetworkConnecetd || wiMaxNetworkConnected );
                 }
             }
             return isNetAvailable;
             }catch(NullPointerException e)
             {
                 return false;
             }catch(Exception e)
             {
                 return false;
             }
         }


    }
0
ViramP

Voici la méthode optimale pour vérifier la connexion Internet. Cette méthode consiste à effectuer une série de vérifications "si le téléphone n'est pas en mode avion, si le téléphone est connecté à un réseau, etc.". Si toutes les vérifications retournent la valeur true, la méthode téléchargera un fichier sur Internet et verra si le contenu correspond à la valeur attendue.

Les avantages de cette méthode par rapport aux autres méthodes qui interrogent un serveur pour vérifier la connexion Internet sont les suivants:

  1. Le moteur d'exécution Android varie d'un téléphone à l'autre. Il est donc possible que vous ne puissiez pas toujours exécuter ces commandes, comme indiqué ci-dessous: Pourquoi le ping fonctionne-t-il sur certains appareils et pas sur d'autres?

  2. La commande ping sur un serveur ne fonctionne pas toujours à cause des pages de connexion/redirection sur des réseaux wifi qui peuvent donner une fausse impression de connexion.

Cette réponse est écrite en kotlin et utilise la bibliothèque Fuel pour télécharger un fichier d'Internet avec la méthodefetchUrlAsString, mais vous pouvez remplacer n'importe quelle bibliothèque tant que vous vous assurez que votre requête HTTP ne l'est pas. mis en cache. Pensez à showConnectionWarning() et hideConnectionWarning() comme équivalents à internet connection status = false et internet connection status = true, respectivement.

private val networkReceiver = object : BroadcastReceiver() {

    override fun onReceive(context: Context?, intent: Intent?) {

        val activeNetworkInfo = (context?.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager).activeNetworkInfo

        if (activeNetworkInfo != null) {
            if (activeNetworkInfo.isConnectedOrConnecting) {
                //Launches a coroutine to fetch file asynchronously 
                launch {
                    try {
                        //Downloads file from url on the internet - use any library you want here.  
                        val connectionStatus = fetchUrlAsString(<url_for_file_on_internet>)
                        //check if the contents of the file is as expected
                        if (connectionStatus == "Connected To Database") {
                            hideConnectionWarning()
                        } else {
                            showConnectionWarning()
                        }
                    } catch (e: Exception) {
                        //Catches an exception - fetchUrlAsString only throws an exception if there is no internet 
                        showConnectionWarning()
                    }
                }
            } else {
                showConnectionWarning()
            }
        } else {
            showConnectionWarning()
        }
    }
}

private suspend fun fetchUrlAsString(url: String): String = suspendCoroutine { cont ->
    url.httpGet().header(Pair("pragma", "no-cache"), Pair("cache-control", "no-cache")).responseString { _, _, result ->

        when (result) {
            is Result.Failure -> {
                cont.resumeWithException(result.getException())
            }
            is Result.Success -> {
                cont.resume(result.value)
            }
        }

    }
}

Vous aurez besoin des autorisations suivantes:

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

Au lieu de vérifier la connexion WIFI ou la connexion de données mobile, essayez de frapper n'importe quel domaine hébergé. Ainsi, vous pouvez vérifier si la connexion WIFI/Mobile a la capacité de se connecter à Internet public.

Les informations ci-dessous seront renvoyées si votre appareil mobile est capable de se connecter au domaine public fourni.

boolean isReachable()
        {
            boolean connected = false;
            String instanceURL = "Your trusted domain name";
            Socket socket;
            try {
                socket = new Socket();
                SocketAddress socketAddress = new InetSocketAddress(instanceURL, 80);
                socket.connect(socketAddress, 5000);
                if (socket.isConnected()) {
                    connected = true;
                    socket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                socket = null;
            }
            return connected;
        }

J'espère que ça vous sera utile.

0
Ragu

La plupart des réponses de ce fil vérifient uniquement si une connexion est disponible, mais ne vérifient pas si cette connexion fonctionne, les autres réponses ne concernent pas l'ensemble du périphérique, ma solution doit fonctionner sur tous les périphériques.

Vous pouvez déposer mon code dans votre activité principale avant de lancer l'application, cela déterminera rapidement s'il existe une connectivité Internet réelle, s'il y a une boîte de dialogue immédiatement abandonnée et que l'application sera lancée, sinon une alerte apparaîtra disant L'application a besoin de la connectivité Internet pour fonctionner.

final AlertDialog alertDialog = new AlertDialog.Builder(this).create();
        alertDialog.setTitle("Checking Connection");
        alertDialog.setMessage("Checking...");
        alertDialog.show();
        new CountDownTimer(5000, 1000) {
            @Override
            public void onTick(long millisUntilFinished) {

                new Thread(new Runnable() {
                    public void run() {
                        try {
                            URL url = new URL("http://web.mit.edu/");
                            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
                            connection.setRequestMethod("GET");
                            connection.setConnectTimeout(5000);
                            isConnected = connection.getResponseCode() == HttpURLConnection.HTTP_OK;
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }).start();

                if (isConnected == false){
                    alertDialog.setMessage("Try " +  (5 - millisUntilFinished/1000) + " of 5.");
                } else {
                    alertDialog.dismiss();
                }
            }
            @Override
            public void onFinish() {
                if (isConnected == false) {
                    alertDialog.dismiss();
                    new AlertDialog.Builder(activity)
                            .setTitle("No Internet")
                            .setMessage("Please connect to Internet first.")
                            .setPositiveButton(Android.R.string.yes, new DialogInterface.OnClickListener() {
                                public void onClick(DialogInterface dialog, int which) {
                                    // kill the app?
                                }
                            })
                            .setIcon(Android.R.drawable.ic_dialog_alert)
                            .show();
                } else {
                    // Launch the app
                }
            }
        }.start();
0
D.Snap

Android fournit à la classe ConnectivityManager le statut de la connexion Internet. La méthode suivante sera très utile pour connaître l'état de la connexion Internet.

Ajoutez d’abord l’autorisation INTERNET et ACCESS_NETWORK_STATE à AndroidManifest.xml

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

Utilisez ensuite la méthode ci-dessous pour vérifier si le périphérique est connecté à Internet ou non. Cette méthode retournera true si le périphérique est connecté à Internet.

public boolean isInternetAvailable(Context context) {
    ConnectivityManager connectivityManager = (ConnectivityManager) 
    context.getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo activeNetwork = connectivityManager.getActiveNetworkInfo();
    return activeNetwork != null
            && activeNetwork.isConnectedOrConnecting();
}

Lien de référence: - http://www.androidtutorialshub.com/Android-check-internet-connection-status/

0
lalit vasan

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

<uses-permission Android:name="Android.permission.INTERNET" />
<uses-permission Android:name="Android.permission.ACCESS_NETWORK_STATE" />
0
Context
public boolean isNetworkAvailable(Context context) {
    ConnectivityManager connectivityManager
            = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
    return activeNetworkInfo != null && activeNetworkInfo.isConnected();
}

Voici la permission dont vous avez besoin:

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