validar - Conexión de internet de Android check

validar si tengo internet android studio

Question

Esta pregunta ya tiene una respuesta aquí:

• ¿Cómo verificar el acceso a Internet en Android? InetAddress nunca agota 46 respuestas

Quiero crear una aplicación que use Internet y estoy intentando crear una función que compruebe si hay una conexión disponible y, si no es así, vaya a una actividad que tenga un botón de reintento y una explicación.

Adjunto está mi código hasta el momento, pero Syntax error, insert "}" to complete MethodBody. el error de Syntax error, insert "}" to complete MethodBody.

Ahora los he estado colocando para tratar de que funcione, pero hasta ahora no hubo suerte ... Se agradecería cualquier ayuda.

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

Answer 1

1- crear nuevo archivo java (haga clic derecho en el paquete. Nuevo> clase> nombre el archivo ConnectionDetector.java

2- agrega el siguiente código al archivo

<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- abre tu MainActivity.java - la actividad donde quieres verificar la conexión, y haz lo siguiente

A- crear y definir la función.

<pre>ConnectionDetector mConnectionDetector;</pre>

B- dentro de "OnCreate" agrega lo siguiente

<pre>mConnectionDetector = new ConnectionDetector(getApplicationContext());</pre>

c- para verificar la conexión, use los siguientes pasos

<pre> if (mConnectionDetector.isConnectingToInternet() == false) {
//no connection- do something
} else {
//there is connection
}</pre>

Answer 2

Aquí hay una función que utilizo como parte de mi clase de Utils :

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

Úselo como: Utils.isNetworkConnected(MainActivity.this);

Answer 3

Después de la declaración "return", no puede escribir ningún código (excluyendo el bloque try-finally). Mueva sus nuevos códigos de actividad antes de las declaraciones de "devolución".

Answer 4

Esta es la otra opción para manejar todas las situaciones:

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

    }
}

Answer 5

Este método verifica si el móvil está conectado a internet y devuelve verdadero si está conectado:

private boolean isNetworkConnected() {
    ConnectivityManager cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);

    return cm.getActiveNetworkInfo() != null;
}

en manifiesto,

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

Editar: Este método realmente verifica si el dispositivo está conectado a internet (existe la posibilidad de que esté conectado a una red pero no a 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;
    }
}

Answer 6

La EDIT de la respuesta aceptada muestra cómo verificar si se puede alcanzar algo en Internet. Tuve que esperar demasiado para obtener una respuesta cuando este no era el caso (con un wifi que NO tiene conexión a Internet). Desafortunadamente InetAddress.getByName no tiene un parámetro de tiempo de espera, por lo que el siguiente código funciona alrededor de eso:

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

Answer 7

Los métodos anteriores funcionan cuando está conectado a una fuente de Wi-Fi o a través de paquetes de datos de teléfono celular. Pero en el caso de la conexión Wi-Fi, hay casos en los que se le pide que inicie sesión como en Cafe. Entonces, en ese caso, su aplicación fallará cuando esté conectado a la fuente de Wi-Fi, pero no con Internet.

Este método funciona 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;

}

Utilice esto en un hilo separado del hilo principal ya que hace una llamada de red y arrojará NetwrokOnMainThreadException si no se sigue.

Y tampoco coloque este método dentro de Crear o cualquier otro método. Póngalo dentro de una clase y acceda a él.

Answer 8

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:

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

en su manifiesto de Android.

para más detalles ve aquí

Answer 9

No puedes crear un método dentro de otro método, move private boolean checkInternetConnection() { method out of onCreate

Answer 10

Pruebe el siguiente código:

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

Answer 11

Puede usar el siguiente fragmento para verificar la conexión a Internet.

Será útil en ambos sentidos que puede verificar qué Tipo de Conexión de RED está disponible para que pueda hacer su proceso de esa manera.

Solo tiene que copiar la siguiente clase y pegar directamente en su paquete.

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

Ahora puedes usar como:

if (InternetConnection.checkConnection(context)) {
    // Its Available...
} else {
    // Not Available...
}

NO OLVIDES TOMAR permiso :) :)

<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" />

Puede modificar en función de sus necesidades.

Gracias.

Answer 12

Simplemente puede hacer ping a un sitio web en línea como google:

public boolean isConnected() throws InterruptedException, IOException
{
    String command = "ping -c 1 google.com";
    return (Runtime.getRuntime().exec (command).waitFor() == 0);
}

Answer 13

Todos los métodos oficiales solo indican si un dispositivo está abierto para la red o no,
Si su dispositivo está conectado a Wifi pero Wifi no está conectado a Internet, estos métodos fallarán (lo que sucede muchas veces). Ningún método de detección de red incorporado informará sobre este escenario, por lo que creó la clase de devolución de llamada asincrónica que volverá en OnConnectionSuccess y 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();

Llamada de red desde la tarea asincrónica

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

Clase real que hará ping al servidor

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

Answer 14

Tuve problemas con la respuesta IsInternetAvailable que no probaba para redes celulares, sino solo si wifi estaba conectado. Esta respuesta funciona tanto para wifi como para datos móviles:

¿Cómo se activa o desactiva la conexión de red en WIFI y 3G (plan de datos) en dispositivos móviles?

Answer 15

Usa este método:

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

Este es el permiso necesario:

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

Answer 16

Use este código para verificar la conexión a 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;
        }

Answer 17

Verifique que esté "conectado" a una red:

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

Verifique que esté "conectado" a una red:

public boolean isInternetAvailable() {
    try {
        final InetAddress address = InetAddress.getByName("www.google.com");
        return !address.equals("");
    } catch (UnknownHostException e) {
        // Log error
    }
    return false;
}

Permiso necesario:

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

https://.com/a/17583324/950427

Answer 18

en manifiesto

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

en codigo,

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

Answer 19

Compruebe la red disponible en Android con velocidad de datos de 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;
    }

Esta función devuelve verdadero o falso. Debe obtener el permiso del usuario

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

Answer 20

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