Android vérifier la connexion Internet
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 ce n'est pas le cas, passez à une activité qui comporte un bouton de nouvelle tentative et une explication.
Ci-joint est mon code jusqu'ici, mais je reçois l'erreur Syntax error, insert "}" to complete MethodBody.
Maintenant, je les mets à essayer de le faire fonctionner, mais jusqu'à présent, 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();
}
}
}
Cette méthode vérifie si le mobile est connecté à Internet et renvoie true si connecté:
private boolean isNetworkConnected() {
ConnectivityManager cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
return cm.getActiveNetworkInfo() != null && cm.getActiveNetworkInfo().isConnected();
}
en 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 si le périphérique est connecté à Internet (il est possible 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) {
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 {
InetAddress address = InetAddress.getByName("www.google.com");
return !address.equals("");
} catch (UnknownHostException e) {
// Log error
}
return false;
}
Permission nécessaire:
<uses-permission Android:name="Android.permission.ACCESS_NETWORK_STATE" />
Vous pouvez simplement faire un ping sur un site Web en ligne comme google:
public boolean isConnected() throws InterruptedException, IOException {
final 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 packs de données de téléphone cellulaire. Mais dans le cas d'une connexion Wi-Fi, il est parfois nécessaire de vous connecter comme dans Café. Donc, dans ce cas, votre application échouera si vous êtes connecté à une source Wi-Fi mais pas à Internet.
Cette méthode fonctionne 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;
}
Veuillez utiliser ceci dans un thread séparé du thread principal car il passe un appel réseau et lève une exception NetwrokOnMainThreadException s'il n'est pas suivi.
Et ne mettez pas cette méthode dans onCreate ni dans aucune autre méthode. Mettez-le dans une classe et accédez-y.
Vous pouvez utiliser l'extrait suivant pour vérifier la connexion Internet.
Cela vous sera utile dans les deux cas pour vérifier quel Type de connexion réseau est disponible afin que vous puissiez effectuer votre processus de cette manière.
Il vous suffit de copier le cours suivant et de le coller directement dans votre package.
/**
*
* @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.
Je vous remercie.
EDIT de la réponse acceptée montre comment vérifier si quelque chose sur Internet est accessible. J'ai dû attendre trop longtemps pour obtenir 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 de délai d'attente, donc le code suivant contourne 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 de méthode dans une autre méthode, déplacez private boolean checkInternetConnection() { méthode hors de onCreate
Toutes les méthodes officielles indiquent uniquement si un périphérique est ouvert au réseau ou non,
Si votre appareil est connecté au Wi-Fi mais que le Wi-Fi n’est pas connecté à Internet, cette méthode échouera (ce qui se produit souvent), aucune méthode de détection de réseau intégrée ne renseignant sur ce scénario, la classe de rappel async créée a été créée. 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 réseau depuis une tâche asynchrone
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 réelle qui sera envoyée 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 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 plus de détail allez ici
Utilisez 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 la permission 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;
}
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;
}
en manifeste
<uses-permission Android:name="Android.permission.ACCESS_WIFI_STATE" />
<uses-permission Android:name="Android.permission.ACCESS_NETWORK_STATE" />
dans du 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;
}
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;
}
Après l'instruction "return", vous ne pouvez plus écrire de code (à l'exception du bloc try-finally). Déplacez vos nouveaux codes d'activité avant les instructions "return".
Voici une fonction que j'utilise dans le cadre de ma classe Utils:
public static boolean isNetworkConnected(Context context) {
ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
return (cm.getActiveNetworkInfo() != null) && cm.getActiveNetworkInfo().isConnectedOrConnecting();
}
Utilisez-le comme: Utils.isNetworkConnected(MainActivity.this);
C'est une autre option pour gérer toutes les situations:
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();
}
}
J'ai eu des problèmes avec la réponse IsInternetAvailable ne pas tester pour les réseaux cellulaires, plutôt que si le wifi était connecté. Cette réponse fonctionne à la fois pour le wifi et les données mobiles:
1- créer un nouveau fichier Java (cliquez avec le bouton droit de la souris sur le paquet. Nouveau> classe> nommez le fichier ConnectionDetector.Java
2- ajouter le code suivant au fichier
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é pour laquelle vous souhaitez vérifier la connexion et procédez comme suit
A- créer et définir la fonction.
ConnectionDetector mConnectionDetector;</pre>
B- dans le "OnCreate" ajouter ce qui suit
mConnectionDetector = new ConnectionDetector(getApplicationContext());
c- pour vérifier la connexion, suivez les étapes suivantes
if (mConnectionDetector.isConnectingToInternet() == false) {
//no connection- do something
} else {
//there is connection
}
Vérifier le réseau disponible dans Android avec la vitesse de transmission des 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 renvoie true ou false. Doit obtenir l'autorisation de l'utilisateur
<uses-permission Android:name="Android.permission.INTERNET"/>
<uses-permission Android:name="Android.permission.ACCESS_NETWORK_STATE" />