¿Cómo verificar el acceso a Internet en Android? InetAddress nunca se agota

AsyncTask un AsyncTask que se supone que verifica el acceso de la red a un nombre de host. Pero doInBackground() nunca se agota el tiempo de espera. Alguien tiene una pista?

 public class HostAvailabilityTask extends AsyncTask { 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(); } } 

Conexión de red / acceso a Internet

  • isConnectedOrConnecting() (usado en la mayoría de las respuestas) comprueba si hay alguna conexión de red
  • Para saber si alguna de esas redes tiene acceso a Internet , use una de las siguientes

A) Ping un servidor (fácil)

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

+ podría correr en el hilo principal

- no funciona en algunos dispositivos antiguos (Galays S3, etc.), bloquea un tiempo si no hay internet disponible.

B) Conectarse a un zócalo en Internet (avanzado)

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

+ muy rápido (de cualquier manera), funciona en todos los dispositivos, muy confiable

- No se puede ejecutar en el hilo de la interfaz de usuario

Esto funciona de manera confiable, en todos los dispositivos, y es muy rápido. Sin embargo, necesita ejecutarse en una tarea separada (por ejemplo, ScheduledExecutorService o AsyncTask ).

Posibles preguntas

  • ¿Es realmente lo suficientemente rápido?

    Sí, muy rápido 😉

  • ¿No hay una manera confiable de verificar internet, aparte de probar algo en internet?

    No sé, pero házmelo saber y editaré mi respuesta.

  • ¿Qué pasa si el DNS está caído?

    Google DNS (por ejemplo, 8.8.8.8 ) es el DNS público más grande del mundo. A partir de 2013 atendió 130 mil millones de solicitudes por día. Digamos que su aplicación probablemente no sea la comidilla del día.

  • ¿Qué permisos son necesarios?

      

    Solo acceso a Internet: sorpresa ^^ (¿Por qué alguna vez pensaste en cómo algunos de los métodos sugeridos aquí incluso podrían tener un pegamento remoto sobre el acceso a Internet sin este permiso?)

Extra: Ejemplo AsyncTask un solo disparo

 class InternetCheck extends AsyncTask { 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: Ejemplo de RxJava/RxAndroid (Kotlin)

 fun hasInternetConnection(): Single { 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 el dispositivo está en modo avión (o presumiblemente en otras situaciones donde no hay una red disponible), cm.getActiveNetworkInfo() será null , por lo que debe agregar una verificación null .

Modificado ( solución de Eddie ) a continuación:

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

También agregue el siguiente permiso a AndroidManifest.xml :

  

Otro punto pequeño, si necesita absolutamente una conexión de red en el momento dado, entonces podría ser mejor usar netInfo.isConnected() lugar de netInfo.isConnectedOrConnecting . Sin embargo, creo que esto depende del uso individual.

No es necesario que sea complejo. La forma más simple y de framework es usar el permiso ACCESS_NETWORK_STATE y simplemente hacer un método conectado

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

También puede usar requestRouteToHost si tiene en mente un host particular y un tipo de conexión (wifi / móvil).

También necesitarás:

  

en su manifiesto de Android.

Para que getActiveNetworkInfo() funcione, debe agregar lo siguiente al manifiesto.

  

mira este código … funcionó para mí 🙂

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

Entonces, defino el controlador:

 Handler h = new Handler() { @Override public void handleMessage(Message msg) { if (msg.what != 1) { // code if not connected } else { // code if connected } } }; 

... y lanza la prueba:

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

Eche un vistazo a la clase ConnectivityManager. Puede usar esta clase para obtener información sobre las conexiones activas en un host. http://developer.android.com/reference/android/net/ConnectivityManager.html

EDITAR: Puedes usar

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

o

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

y analizar la enumeración DetailedState del objeto NetworkInfo devuelto

EDITAR EDITAR: Para saber si puede acceder a un host, puede usar

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

Obviamente, estoy usando Context.getSystemService (Context.CONNECTIVITY_SERVICE) como proxy para decir

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

Encontrado en y modificado (!) Desde este enlace :

En su archivo de manifiesto, agregue al menos:

  

Probablemente ya tenga el permiso de INTERNET si está accediendo a él. Luego, una función booleana que permite probar la conectividad es:

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

Hice este código, es el más simple y solo es un booleano. preguntando if(isOnline()){

Se obtiene si hay una conexión y si se puede conectar a una página el código de estado 200 (conexión estable).

Asegúrese de agregar los permisos correctos de INTERNET y ACCESS_NETWORK_STATE .

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

Funciona para mí:

Para verificar la disponibilidad de la red:

 private Boolean isNetworkAvailable() { ConnectivityManager connectivityManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE); NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo(); return activeNetworkInfo != null && activeNetworkInfo.isConnectedOrConnecting();} 

Para verificar el acceso a internet:

 public Boolean isOnline() { try { Process p1 = java.lang.Runtime.getRuntime().exec("ping -c 1 www.google.com"); int returnVal = p1.waitFor(); boolean reachable = (returnVal==0); return reachable; } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } return false; } 

De todo lo que he visto hasta ahora el camino más corto y limpio debería ser:

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

PD: Esto no hace ping a ningún host, solo comprueba el estado de conexión, por lo que si su enrutador no tiene conexión a Internet y su dispositivo está conectado a él, este método volverá a ser cierto aunque no tenga conexión a Internet.
Para una prueba real, recomendaría excluir una solicitud de HttpHead (por ejemplo, a http://www.google.com) y verificar el estado, si está bien 200 todo está bien y su dispositivo tiene una conexión a Internet.

Un caso de uso importante en los dispositivos móviles para garantizar que exista una conexión real. Este es un problema común cuando un usuario móvil ingresa a una red Wifi con un “Portal cautivo”, en el cual necesita iniciar sesión. Uso esta función de locking en segundo plano para asegurar que exista una conexión.

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

Este es el método que uso:

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

Mejor aún, verifique que esté “conectado”:

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

Aquí es cómo usar el método:

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

Permiso necesario:

  

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

Puede iterar sobre todas las conexiones de red y verificar si hay al menos una conexión 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; } 

Para mí no fue una buena práctica verificar el estado de la conexión en la clase Activity, porque

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

debe llamarse allí, o debe presionar hacia abajo su instancia de Actividad (contexto) a la clase de controlador de conexión para poder verificar el estado de conexión allí. Cuando no hay conexión disponible (wifi, red) capto la excepción UnknownHostException :

 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 esta forma puedo manejar este caso junto con los otros casos en la misma clase (mi servidor siempre responde de nuevo con una cadena json)

Es un trabajo para mi Pruébalo.

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

Hay más de una manera

Primero, la forma más corta pero ineficiente

El permiso de estado de red solo es necesario

  

Entonces este método,

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

Como se ve en las respuestas ConnectivityManager es una solución, acabo de agregarlo dentro de un método, este es un método simplificado que se usa
ConnectivityManager devuelve verdadero si hay acceso a la red, no acceso a Internet, significa que si su WiFi está conectada a un enrutador pero el enrutador no tiene conexión a Internet, devuelve la verdad, verifica la disponibilidad de la conexión

En segundo lugar, manera eficiente

Estado de red y permisos de Internet necesarios

   

Entonces esta clase,

  public class CheckInternetAsyncTask extends AsyncTask { 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 } } } 

Llamar CheckInternetAsyncTask

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

Algunas explicaciones:

  • tienes que verificar Internet en AsyncTask , de lo contrario puede lanzar android.os.NetworkOnMainThreadException en algunos casos

  • ConnectivityManager solía verificar el acceso a la red si la solicitud de envío verdadero (Ping)

  • Solicitud de envío a http://clients3.google.com/generate_204 , se sabe que esta conocida URL devuelve una página vacía con un estado HTTP 204 esto es más rápido y más eficiente que http://www.google.com , leer esto si tiene un sitio web, prefiere colocar su sitio web en lugar de google, solo si lo usa dentro de la aplicación

  • El tiempo de espera se puede cambiar el rango (20 ms -> 2000 ms), 1500 ms se utiliza comúnmente

Estoy usando este código en lugar 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(); } 

No es complejo comprobar el estado de la conexión de red / Internet de Android. La siguiente clase DetectConnection te ayudará a verificar este estado:

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

Para obtener más información, visite Cómo verificar el estado de conectividad de red / Internet de Android.

El mejor enfoque:

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

A continuación está el código de mi clase de Utils :

 public static boolean isNetworkAvailable(Context context) { ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE); NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo(); return activeNetworkInfo != null && activeNetworkInfo.isConnected(); } 
 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(); } } 

Puede usar este método para detectar la disponibilidad de la red

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

The other answers that use ConnectivityManager are wrong because having a network connection doesn’t mean you have internet access. For example, the user might be connected to a coffee shop’s WiFi portal but can’t get to the internet. To check that the internet is accessible you have to try to connect to an actual server. Normally when you want to do this you have a specific server in mind that you want to connect to, so go ahead and check if you can connect to that server. Here’s a simple method for checking connectivity to a server.

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

The reason for setting the ConnectTimeout is that otherwise it defaults to the TCP timeout which can be many seconds long.

Note also that Android won’t let you run this on your main thread.

This method gives you the option for a really fast method (for real time feedback) or a slower method (for one off checks that require reliability)

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

I have applied the solution provided by @Levit and created function that will not call the extra Http Request.

It will solve the error 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; } 

Now call it like,

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

Just create the following class which checks for an internet connection:

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

This class simply contains a method which returns the boolean value of the connection status. Therefore in simple terms, if the method finds a valid connection to the Internet, the return value is true , otherwise false if no valid connection is found.

The following method in the MainActivity then calls the result from the method previously described, and prompts the user to act accordingly:

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

In the above code, if the result is false, (therefore there is no internet connection, the user is taken to the Android wi-fi panel, where he is prompted to connect to a wi-fi hotspot.

Update 29/06/2015 If you are using Xamarin.Android and want to check for connectivity, you can use a Nuget package that would give you this functionality on multiple platforms. Good candidates are here and here . [End of Update]

The Answers above are quite good, but they are all in Java, and almost all of them check for a connectivity. In my case, I needed to have connectivity with a specific type of connection and I am developing on Xamarin.Android. Moreover, I do not pass a reference to my activities Context in the Hardware layer, I use the Application Context. So here is my solution, in case somebody comes here with similar requirements. I have not done full testing though, will update the answer once I am done with my testing

 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 } 

I have gone through all the answers and i come up with my own answer which first check whether Internet is available and if Internet is available then it check whether it is active or not.

I have included all necessary method and classes to check for active Internet connection.

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

You can check whether Internet is active using below code:

  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); } }); } 
 public boolean isOnline() { boolean var = false; ConnectivityManager cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE); if ( cm.getActiveNetworkInfo() != null ) { var = true; } return var; } 

I have done it this way. A little bit shorter and more readable I guess.

¡Aclamaciones!

Saiyan