Android vérifier la connexion internet [dupliquer]
cette question a déjà une réponse ici:
- Comment vérifier l'accès à Internet sur Android? InetAddress n'arrive jamais à expiration 49 réponses
je veux créer une application qui utilise internet et j'essaie de créer une fonction qui vérifie si une connexion est disponible et si elle n'est pas, allez à une activité qui a un bouton de retouche et une explication.
attaché est mon code jusqu'à présent, mais je reçois l'erreur Syntax error, insert "}" to complete MethodBody.
maintenant j'ai placé ceux-ci dans essayer de le faire fonctionner, mais jusqu'ici pas de chance... Toute aide serait appréciée.
public class TheEvoStikLeagueActivity extends Activity {
private final int SPLASH_DISPLAY_LENGHT = 3000;
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
setContentView(R.layout.main);
private boolean checkInternetConnection() {
ConnectivityManager conMgr = (ConnectivityManager) getSystemService (Context.CONNECTIVITY_SERVICE);
// ARE WE CONNECTED TO THE NET
if (conMgr.getActiveNetworkInfo() != null
&& conMgr.getActiveNetworkInfo().isAvailable()
&& conMgr.getActiveNetworkInfo().isConnected()) {
return true;
/* New Handler to start the Menu-Activity
* and close this Splash-Screen after some seconds.*/
new Handler().postDelayed(new Runnable() {
public void run() {
/* Create an Intent that will start the Menu-Activity. */
Intent mainIntent = new Intent(TheEvoStikLeagueActivity.this, IntroActivity.class);
TheEvoStikLeagueActivity.this.startActivity(mainIntent);
TheEvoStikLeagueActivity.this.finish();
}
}, SPLASH_DISPLAY_LENGHT);
} else {
return false;
Intent connectionIntent = new Intent(TheEvoStikLeagueActivity.this, HomeActivity.class);
TheEvoStikLeagueActivity.this.startActivity(connectionIntent);
TheEvoStikLeagueActivity.this.finish();
}
}
}
20 réponses
cette méthode vérifie si mobile est connecté à internet et retourne true si connecté:
private boolean isNetworkConnected() {
ConnectivityManager cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
return cm.getActiveNetworkInfo() != null;
}
dans le manifeste,
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
Edit: Cette méthode vérifie en fait si le périphérique est connecté à internet(il y a une possibilité qu'il soit connecté à un réseau mais pas à internet).
public boolean isInternetAvailable() {
try {
InetAddress ipAddr = InetAddress.getByName("google.com");
//You can replace it with your name
return !ipAddr.equals("");
} catch (Exception e) {
return false;
}
}
assurez-vous qu'il est "connecté" à un réseau:
public boolean isNetworkAvailable(Context context) {
final ConnectivityManager connectivityManager = ((ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE));
return connectivityManager.getActiveNetworkInfo() != null && connectivityManager.getActiveNetworkInfo().isConnected();
}
assurez-vous qu'il est "connecté" à un réseau:
public boolean isInternetAvailable() {
try {
final InetAddress address = InetAddress.getByName("www.google.com");
return !address.equals("");
} catch (UnknownHostException e) {
// Log error
}
return false;
}
Permission neededed:
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
vous pouvez simplement tracer un site Web en ligne comme google:
public boolean isConnected() throws InterruptedException, IOException
{
String command = "ping -c 1 google.com";
return (Runtime.getRuntime().exec(command).waitFor() == 0);
}
les méthodes ci-dessus fonctionnent lorsque vous êtes connecté à une source Wi-Fi ou via des paquets de données de téléphone cellulaire. Mais en cas de connexion Wi-Fi Il ya des cas où il vous est demandé de plus de S'inscrire comme dans le café. Donc, dans ce cas, votre application échouera car vous êtes connecté à Wi-Fi source mais pas avec L'Internet.
Cette méthode fonctionne très bien.
public static boolean isConnected(Context context) {
ConnectivityManager cm = (ConnectivityManager)context
.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
if (activeNetwork != null && activeNetwork.isConnected()) {
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(1000); // mTimeout is in seconds
urlc.connect();
if (urlc.getResponseCode() == 200) {
return true;
} else {
return false;
}
} catch (IOException e) {
Log.i("warning", "Error checking internet connection", e);
return false;
}
}
return false;
}
s'il vous plaît utilisez ceci dans un thread séparé du thread principal car il fait un appel réseau et lancera Countrokonmainthreadexception si elle n'est pas suivie.
et aussi ne mettez pas cette méthode à l'intérieur onCreate ou toute autre méthode. Mettez-le dans une classe et accédez-y.
L'édition de la réponse acceptée montre comment vérifier si quelque chose sur internet peut être atteint. J'ai dû attendre trop longtemps pour une réponse alors que ce n'était pas le cas (avec un wifi qui n'a pas de connexion internet). Malheureusement InetAddress.getByName n'a pas de paramètre timeout, donc le code suivant fonctionne autour de cela:
private boolean internetConnectionAvailable(int timeOut) {
InetAddress inetAddress = null;
try {
Future<InetAddress> future = Executors.newSingleThreadExecutor().submit(new Callable<InetAddress>() {
@Override
public InetAddress call() {
try {
return InetAddress.getByName("google.com");
} catch (UnknownHostException e) {
return null;
}
}
});
inetAddress = future.get(timeOut, TimeUnit.MILLISECONDS);
future.cancel(true);
} catch (InterruptedException e) {
} catch (ExecutionException e) {
} catch (TimeoutException e) {
}
return inetAddress!=null && !inetAddress.equals("");
}
vous ne pouvez pas créer une méthode à l'intérieur d'une autre méthode, déplacer private boolean checkInternetConnection() { méthode hors de onCreate
vous pouvez utiliser l'extrait suivant pour vérifier la connexion Internet.
il sera utile dans les deux sens que vous pouvez vérifier quel Type de réseau La connexion est disponible, de sorte que vous pouvez faire de votre processus.
vous avez juste à copier la classe suivante et coller directement dans votre paquet.
/**
*
* @author Pratik Butani
*
*/
public class InternetConnection {
/** CHECK WHETHER INTERNET CONNECTION IS AVAILABLE OR NOT */
public static boolean checkConnection(Context context) {
final ConnectivityManager connMgr = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo activeNetworkInfo = connMgr.getActiveNetworkInfo();
if (activeNetworkInfo != null) { // connected to the internet
Toast.makeText(context, activeNetworkInfo.getTypeName(), Toast.LENGTH_SHORT).show();
if (activeNetworkInfo.getType() == ConnectivityManager.TYPE_WIFI) {
// connected to wifi
return true;
} else if (activeNetworkInfo.getType() == ConnectivityManager.TYPE_MOBILE) {
// connected to the mobile provider's data plan
return true;
}
}
return false;
}
}
Maintenant vous pouvez utiliser comme:
if (InternetConnection.checkConnection(context)) {
// Its Available...
} else {
// Not Available...
}
N'OUBLIEZ PAS de PRENDRE l'Autorisation :) :)
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
, Vous pouvez modifier en fonction de vos besoins.
Merci.
toutes les méthodes officielles indique seulement si un dispositif est ouvert pour le réseau ou non,
si votre appareil est connecté au Wifi mais que le Wifi n'est pas connecté à internet alors cette méthode échouera (ce qui arrive souvent), aucune méthode de détection réseau intégrée ne parlera de ce scénario, donc créé une classe de rappel Async qui reviendra dans onConnectionSuccess et onConnectionFail
new CheckNetworkConnection(this, new CheckNetworkConnection.OnConnectionCallback() {
@Override
public void onConnectionSuccess() {
Toast.makeText(context, "onSuccess()", toast.LENGTH_SHORT).show();
}
@Override
public void onConnectionFail(String msg) {
Toast.makeText(context, "onFail()", toast.LENGTH_SHORT).show();
}
}).execute();
Appel du Réseau de async Task
public class CheckNetworkConnection extends AsyncTask<Void, Void, Boolean> {
private OnConnectionCallback onConnectionCallback;
private Context context;
public CheckNetworkConnection(Context con, OnConnectionCallback onConnectionCallback) {
super();
this.onConnectionCallback = onConnectionCallback;
this.context = con;
}
@Override
protected void onPreExecute() {
super.onPreExecute();
}
@Override
protected Boolean doInBackground(Void... params) {
if (context == null)
return false;
boolean isConnected = new NetWorkInfoUtility().isNetWorkAvailableNow(context);
return isConnected;
}
@Override
protected void onPostExecute(Boolean b) {
super.onPostExecute(b);
if (b) {
onConnectionCallback.onConnectionSuccess();
} else {
String msg = "No Internet Connection";
if (context == null)
msg = "Context is null";
onConnectionCallback.onConnectionFail(msg);
}
}
public interface OnConnectionCallback {
void onConnectionSuccess();
void onConnectionFail(String errorMsg);
}
}
classe actuelle qui sera ping au serveur
class NetWorkInfoUtility {
public boolean isWifiEnable() {
return isWifiEnable;
}
public void setIsWifiEnable(boolean isWifiEnable) {
this.isWifiEnable = isWifiEnable;
}
public boolean isMobileNetworkAvailable() {
return isMobileNetworkAvailable;
}
public void setIsMobileNetworkAvailable(boolean isMobileNetworkAvailable) {
this.isMobileNetworkAvailable = isMobileNetworkAvailable;
}
private boolean isWifiEnable = false;
private boolean isMobileNetworkAvailable = false;
public boolean isNetWorkAvailableNow(Context context) {
boolean isNetworkAvailable = false;
ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
setIsWifiEnable(connectivityManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI).isConnected());
setIsMobileNetworkAvailable(connectivityManager.getNetworkInfo(ConnectivityManager.TYPE_MOBILE).isConnected());
if (isWifiEnable() || isMobileNetworkAvailable()) {
/*Sometime wifi is connected but service provider never connected to internet
so cross check one more time*/
if (isOnline())
isNetworkAvailable = true;
}
return isNetworkAvailable;
}
public boolean isOnline() {
/*Just to check Time delay*/
long t = Calendar.getInstance().getTimeInMillis();
Runtime runtime = Runtime.getRuntime();
try {
/*Pinging to Google server*/
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();
} finally {
long t2 = Calendar.getInstance().getTimeInMillis();
Log.i("NetWork check Time", (t2 - t) + "");
}
return false;
}
}
Pas besoin d'être complexe. La manière la plus simple et framework est d'utiliser ACCESS_NETWORK_STATE permission et juste faire 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 un hôte particulier et le type de connexion (wifi/mobile) à l'esprit.
vous aurez aussi besoin de:
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
dans votre manifeste androïde.
pour plus de détails allez ici
utiliser cette méthode:
public static boolean isOnline() {
ConnectivityManager cm = (ConnectivityManager) context
.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo netInfo = cm.getActiveNetworkInfo();
return netInfo != null && netInfo.isConnectedOrConnecting();
}
C'est l'autorisation nécessaire:
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
essayez le code suivant:
public static boolean isNetworkAvailable(Context context) {
boolean outcome = false;
if (context != null) {
ConnectivityManager cm = (ConnectivityManager) context
.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo[] networkInfos = cm.getAllNetworkInfo();
for (NetworkInfo tempNetworkInfo : networkInfos) {
/**
* Can also check if the user is in roaming
*/
if (tempNetworkInfo.isConnected()) {
outcome = true;
break;
}
}
}
return outcome;
}
dans le manifeste
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
en code,
public static boolean isOnline(Context ctx) {
if (ctx == null)
return false;
ConnectivityManager cm =
(ConnectivityManager) ctx.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo netInfo = cm.getActiveNetworkInfo();
if (netInfo != null && netInfo.isConnectedOrConnecting()) {
return true;
}
return false;
}
après l'instruction" return", vous ne pouvez pas écrire de code(à l'exclusion du bloc "try-finally"). Déplacez vos nouveaux codes d'activité avant les énoncés "retour".
public boolean checkInternetConnection(Context context) {
ConnectivityManager connectivity = (ConnectivityManager) context
.getSystemService(Context.CONNECTIVITY_SERVICE);
if (connectivity == null) {
return false;
} else {
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;
}
utilisez ce code pour vérifier la connexion internet
ConnectivityManager connectivityManager = (ConnectivityManager) ctx
.getSystemService(Context.CONNECTIVITY_SERVICE);
if ((connectivityManager
.getNetworkInfo(ConnectivityManager.TYPE_MOBILE) != null && connectivityManager
.getNetworkInfo(ConnectivityManager.TYPE_MOBILE).getState() == NetworkInfo.State.CONNECTED)
|| (connectivityManager
.getNetworkInfo(ConnectivityManager.TYPE_WIFI) != null && connectivityManager
.getNetworkInfo(ConnectivityManager.TYPE_WIFI)
.getState() == NetworkInfo.State.CONNECTED)) {
return true;
} else {
return false;
}
Voici une fonction que j'utilise dans ma classe Utils :
public static boolean isNetworkConnected(Context context) {
ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
return (cm.getActiveNetworkInfo() != null) && cm.getActiveNetworkInfo().isConnectedOrConnecting();
}
utiliser comme: Utils.isNetworkConnected(MainActivity.this);
1 - créer un nouveau fichier java (clic droit sur le paquet. nouveau > classe > nom du fichier ConnectionDetector.java
2-ajouter le code suivant au fichier
<pre>package <add you package name> example com.example.example;
import android.content.Context;
import android.net.ConnectivityManager;
public class ConnectionDetector {
private Context mContext;
public ConnectionDetector(Context context){
this.mContext = context;
}
public boolean isConnectingToInternet(){
ConnectivityManager cm = (ConnectivityManager)mContext.getSystemService(Context.CONNECTIVITY_SERVICE);
if(cm.getActiveNetworkInfo() != null && cm.getActiveNetworkInfo().isConnected() == true)
{
return true;
}
return false;
}
}
3-Ouvrez votre MainActivity.java - l'activité où vous voulez vérifier la connexion, et faire ce qui suit
a-créer et définir la fonction.
<pre>ConnectionDetector mConnectionDetector;</pre>
B - à l'intérieur du" OnCreate " ajouter le suivant
<pre>mConnectionDetector = new ConnectionDetector(getApplicationContext());</pre>
C - pour vérifier la connexion, suivre les étapes suivantes
<pre> if (mConnectionDetector.isConnectingToInternet() == false) {
//no connection- do something
} else {
//there is connection
}</pre>
j'ai eu des problèmes avec la réponse Isinternet disponible ne pas tester pour les réseaux cellulaires, plutôt que si wifi était connecté. Cette réponse fonctionne à la fois pour le wifi et les données mobiles:
c'est l'autre option pour gérer toute situation:
public void isNetworkAvailable() {
ConnectivityManager connectivityManager = (ConnectivityManager) ctx.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
if (activeNetworkInfo != null && activeNetworkInfo.isConnected()) {
} else {
Toast.makeText(ctx, "Internet Connection Is Required", Toast.LENGTH_LONG).show();
}
}
vérifier réseau disponible sur android avec la vitesse de données internet.
public boolean isConnectingToInternet(){
ConnectivityManager connectivity = (ConnectivityManager) Login_Page.this.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)
{
try
{
HttpURLConnection urlc = (HttpURLConnection) (new URL("http://www.google.com").openConnection());
urlc.setRequestProperty("User-Agent", "Test");
urlc.setRequestProperty("Connection", "close");
urlc.setConnectTimeout(500); //choose your own timeframe
urlc.setReadTimeout(500); //choose your own timeframe
urlc.connect();
int networkcode2 = urlc.getResponseCode();
return (urlc.getResponseCode() == 200);
} catch (IOException e)
{
return (false); //connectivity exists, but no internet.
}
}
}
return false;
}
cette fonction retourne vrai ou faux. Doit obtenir la permission de l'utilisateur
<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />