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();
}
}
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 */}
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.
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.
Pour que getActiveNetworkInfo() fonctionne, vous devez ajouter ce qui suit au manifeste.
<uses-permission Android:name="Android.permission.ACCESS_NETWORK_STATE" />
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
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();
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;
}
}
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;
}
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;
}
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 à utiliserConnectivityManager 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 jeterAndroid.os.NetworkOnMainThreadExceptiondans certains casConnectivityManagerutilisé 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 quehttp://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é
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.
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" />
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;
}
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;
}
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());
}}
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)
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();
}
}
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
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;
}
}
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
}
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();
}
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;
}
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;
}
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();
}
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" />
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.
Ceci est couvert dans Android docs http://developer.Android.com/training/monitoring-device-state/connectivity-monitoring.html
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);
}
});
}
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
}
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.
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.
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
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);
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
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;
}
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" />
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;
}
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; }
}
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.
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" />
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;
}
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();
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"/>
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;
}
}
}
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:
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?
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" />
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.
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();
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/
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" />
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"/>