¿Cómo puedo ver si el Wi-Fi está conectado en Android?

No quiero que mi usuario incluso intente descargar algo a menos que tengan Wi-Fi conectado. Sin embargo, parece que solo puedo decir si el Wi-Fi está habilitado, pero aún podrían tener una conexión 3G.

android.net.wifi.WifiManager m = (WifiManager) getSystemService(WIFI_SERVICE);
android.net.wifi.SupplicantState s = m.getConnectionInfo().getSupplicantState();
NetworkInfo.DetailedState state = WifiInfo.getDetailedStateOf(s);
if (state != NetworkInfo.DetailedState.CONNECTED) {
    return false;
}

Sin embargo, el estado no es lo que esperaría. A pesar de que el Wi-Fi está conectado, estoy obteniendo OBTAINING_IPADDRel estado.

Debería poder usar el ConnectivityManager para obtener el estado del adaptador Wi-Fi. Desde allí puede verificar si está conectado o incluso disponible .

ConnectivityManager connManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo mWifi = connManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);

if (mWifi.isConnected()) {
    // Do whatever
}

NOTA: Debe tenerse en cuenta (para nosotros n00bies aquí) que debe agregar

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

para usted

AndroidManifest.xml para que esto funcione.

NOTA2 : public NetworkInfo getNetworkInfo (int networkType)ahora está en desuso:

Este método fue desaprobado en el nivel 23 de API. Este método no admite múltiples redes conectadas del mismo tipo. Utilice getAllNetworks () y getNetworkInfo (android.net.Network) en su lugar.

NOTA3 : public static final int TYPE_WIFIahora está en desuso:

Esta constante quedó en desuso en el nivel 28 de la API. En su lugar, las aplicaciones deben usar NetworkCapabilities.hasTransport (int) o requestNetwork (NetworkRequest, NetworkCallback) para solicitar una red adecuada. para transportes compatibles.

Dado que el método NetworkInfo.isConnected () ahora está en desuso en API-23 , aquí hay un método que detecta si el adaptador de Wi-Fi está encendido y también conectado a un punto de acceso usando WifiManager:

private boolean checkWifiOnAndConnected() {
    WifiManager wifiMgr = (WifiManager) getSystemService(Context.WIFI_SERVICE);

    if (wifiMgr.isWifiEnabled()) { // Wi-Fi adapter is ON

        WifiInfo wifiInfo = wifiMgr.getConnectionInfo();

        if( wifiInfo.getNetworkId() == -1 ){
            return false; // Not connected to an access point
        }
        return true; // Connected to an access point
    }
    else {
        return false; // Wi-Fi adapter is OFF
    }
}

Simplemente uso lo siguiente:

SupplicantState supState; 
wifiManager = (WifiManager) getSystemService(Context.WIFI_SERVICE);
WifiInfo wifiInfo = wifiManager.getConnectionInfo();
supState = wifiInfo.getSupplicantState();

Que devolverá uno de estos estados en el momento en que llame a getSupplicantState ();

ASOCIADO - Asociación completada.

ASOCIAR - Intentando asociar con un punto de acceso.

COMPLETADO: se completó toda la autenticación.

DESCONECTADO: este estado indica que el cliente no está asociado, pero es probable que comience a buscar un punto de acceso.

DORMANTE: un estado agregado por Android que se informa cuando un cliente emite un comando DESCONEXIÓN explícito.

FOUR_WAY_HANDSHAKE - WPA 4-Way Key Handshake en progreso.

GROUP_HANDSHAKE - WPA Group Key Handshake en progreso.

INACTIVO - Estado inactivo.

NO VÁLIDO: un pseudoestado que normalmente nunca debería verse.

ESCANEO - Escaneo para una red.

NO INICIALIZADO - Sin conexión.

Estoy usando esto en mis aplicaciones para verificar si la red activa es Wi-Fi:

ConnectivityManager cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo ni = cm.getActiveNetworkInfo();
if (ni != null && ni.getType() == ConnectivityManager.TYPE_WIFI)
{

    // Do your work here

}

Eché un vistazo a algunas preguntas como esta y se me ocurrió esto:

ConnectivityManager connManager = (ConnectivityManager) getSystemService(CONNECTIVITY_SERVICE);
NetworkInfo wifi = connManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
NetworkInfo mobile = connManager .getNetworkInfo(ConnectivityManager.TYPE_MOBILE);

if (wifi.isConnected()){
    // If Wi-Fi connected
}

if (mobile.isConnected()) {
    // If Internet connected
}

Lo uso para mi verificación de licencia en Root Toolbox PRO, y parece funcionar muy bien.

Si bien la respuesta de Jason es correcta, hoy en día getNetWorkInfo (int) es un método obsoleto. Entonces, la siguiente función sería una buena alternativa:

public static boolean isWifiAvailable (Context context)
{
    boolean br = false;
    ConnectivityManager cm = null;
    NetworkInfo ni = null;

    cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    ni = cm.getActiveNetworkInfo();
    br = ((null != ni) && (ni.isConnected()) && (ni.getType() == ConnectivityManager.TYPE_WIFI));

    return br;
}

Usando WifiManagerusted puede hacer:

WifiManager wifi = (WifiManager) getSystemService (Context.WIFI_SERVICE);
if (wifi.getConnectionInfo().getNetworkId() != -1) {/* connected */}

El método getNeworkId devuelve -1 solo cuando no está conectado a una red;

ConnectivityManager manager = (ConnectivityManager) getSystemService(CONNECTIVITY_SERVICE);
boolean is3g = manager.getNetworkInfo(
                  ConnectivityManager.TYPE_MOBILE).isConnectedOrConnecting();
boolean isWifi = manager.getNetworkInfo(
                    ConnectivityManager.TYPE_WIFI).isConnectedOrConnecting();

Log.v("", is3g + " ConnectivityManager Test " + isWifi);
if (!is3g && !isWifi) {
    Toast.makeText(
        getApplicationContext(),
        "Please make sure, your network connection is ON ",
        Toast.LENGTH_LONG).show();
}
else {
    // Put your function() to go further;
}

El siguiente código (en Kotlin) funciona desde API 21 hasta al menos la versión API actual (API 29). La función getWifiState () devuelve uno de los 3 valores posibles para el estado de la red WiFi: Disable, EnabledNotConnected y Connected que se definieron en una clase enum. Esto permite tomar decisiones más detalladas, como informar al usuario que habilite WiFi o, si ya está habilitado, conectarse a una de las redes disponibles. Pero si todo lo que se necesita es un valor booleano que indique si la interfaz WiFi está conectada a una red, entonces la otra función esWifiConnected () le dará eso. Utiliza el anterior y compara el resultado con Connected.

Está inspirado en algunas de las respuestas anteriores, pero trata de resolver los problemas introducidos por la evolución de las API de Android o la disponibilidad cada vez mayor de IP V6. El truco era usar:

wifiManager.connectionInfo.bssid != null 

en vez de:

1. getIpAddress () == 0 que solo es válido para IP V4 o
2. getNetworkId () == -1 que ahora requiere otro permiso especial (Ubicación)

De acuerdo con la documentación: https://developer.android.com/reference/kotlin/android/net/wifi/WifiInfo.html#getbssid devolverá nulo si no está conectado a una red. E incluso si no tenemos permiso para obtener el valor real, aún devolverá algo más que nulo si estamos conectados.

También tenga en cuenta lo siguiente:

En las versiones anteriores a android.os.Build.VERSION_CODES # N, este objeto solo debe obtenerse de un Context # getApplicationContext (), y no de ningún otro contexto derivado para evitar pérdidas de memoria dentro del proceso de llamada.

En el Manifiesto, no olvides agregar:

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

El código propuesto es:

class MyViewModel(application: Application) : AndroidViewModel(application) {

   // Get application context
    private val myAppContext: Context = getApplication<Application>().applicationContext

   // Define the different possible states for the WiFi Connection
    internal enum class WifiState {
        Disabled,               // WiFi is not enabled
        EnabledNotConnected,    // WiFi is enabled but we are not connected to any WiFi network
        Connected,              // Connected to a WiFi network
    }

    // Get the current state of the WiFi network
    private fun getWifiState() : WifiState {

        val wifiManager : WifiManager = myAppContext.applicationContext.getSystemService(Context.WIFI_SERVICE) as WifiManager

        return if (wifiManager.isWifiEnabled) {
                    if (wifiManager.connectionInfo.bssid != null)
                        WifiState.Connected
                    else
                        WifiState.EnabledNotConnected
               } else {
                    WifiState.Disabled
               }
    }

    // Returns true if we are connected to a WiFi network
    private fun isWiFiConnected() : Boolean {
        return (getWifiState() == WifiState.Connected)
    }
}

La NetworkInfoclase está en desuso a partir del nivel 29 de API, junto con los métodos de acceso relacionados como ConnectivityManager#getNetworkInfo()y ConnectivityManager#getActiveNetworkInfo().

La documentación ahora sugiere que las personas usen la ConnectivityManager.NetworkCallbackAPI para el monitoreo de devolución de llamada asincrónica, o que usen ConnectivityManager#getNetworkCapabilitieso ConnectivityManager#getLinkPropertiespara el acceso sincronizado de la información de la red

En cambio, las personas que llaman deben usar la API ConnectivityManager.NetworkCallback para obtener información sobre los cambios de conectividad, o cambiar para usar ConnectivityManager # getNetworkCapabilities o ConnectivityManager # getLinkProperties para obtener información de forma sincrónica.

Para verificar si WiFi está conectado, aquí está el código que uso:

Kotlin:

val connMgr = applicationContext.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager?
connMgr?: return false
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
    val network: Network = connMgr.activeNetwork ?: return false
    val capabilities = connMgr.getNetworkCapabilities(network)
    return capabilities != null && capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
} else {
    val networkInfo = connMgr.activeNetworkInfo ?: return false
    return networkInfo.isConnected && networkInfo.type == ConnectivityManager.TYPE_WIFI
}

Java:

ConnectivityManager connMgr = (ConnectivityManager) getApplicationContext().getSystemService(Context.CONNECTIVITY_SERVICE);
if (connMgr == null) {
    return false;
}
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
    Network network = connMgr.getActiveNetwork();
    if (network == null) return false;
    NetworkCapabilities capabilities = connMgr.getNetworkCapabilities(network);
    return capabilities != null && capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI);
} else {
    NetworkInfo networkInfo = connMgr.getActiveNetworkInfo();
    return networkInfo.isConnected() && networkInfo.getType() == ConnectivityManager.TYPE_WIFI;
}

Recuerde agregar también permiso ACCESS_NETWORK_STATEa su archivo de manifiesto.

Prueba este método.

public boolean isInternetConnected() {
    ConnectivityManager conMgr = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
    boolean ret = true;
    if (conMgr != null) {
        NetworkInfo i = conMgr.getActiveNetworkInfo();

        if (i != null) {
            if (!i.isConnected()) {
                ret = false;
            }

            if (!i.isAvailable()) {
                ret = false;
            }
        }

        if (i == null)
            ret = false;
    } else
        ret = false;
    return ret;
}

Este método ayudará a encontrar la conexión a Internet disponible o no.

Esto funciona para mi:

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

    // Mobile
    State mobile = conMan.getNetworkInfo(ConnectivityManager.TYPE_MOBILE).getState();

    // Wi-Fi
    State wifi = conMan.getNetworkInfo(ConnectivityManager.TYPE_WIFI).getState();

    // And then use it like this:

    if (mobile == NetworkInfo.State.CONNECTED || mobile == NetworkInfo.State.CONNECTING)
    {
        Toast.makeText(Wifi_Gprs.this,"Mobile is Enabled :) ....",Toast.LENGTH_LONG).show();
    }
    else if (wifi == NetworkInfo.State.CONNECTED || wifi == NetworkInfo.State.CONNECTING)
    {
        Toast.makeText(Wifi_Gprs.this,"Wifi is Enabled  :) ....",Toast.LENGTH_LONG).show();
    }
    else
    {
        Toast.makeText(Wifi_Gprs.this,"No Wifi or Gprs Enabled :( ....",Toast.LENGTH_LONG).show();
    }

Y agregue este permiso:

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

Muchas de las respuestas usan código obsoleto, o código disponible en versiones API más altas. Ahora uso algo como esto

ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        if(connectivityManager != null) {
            for (Network net : connectivityManager.getAllNetworks()) {
                NetworkCapabilities nc = connectivityManager.getNetworkCapabilities(net);
                if (nc != null && nc.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
                        && nc.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET))
                    return true;
            }
        }
        return false;

Esto es lo que uso como método de utilidad en mis aplicaciones:

public static boolean isDeviceOnWifi(final Context context) {
        ConnectivityManager connManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo mWifi = connManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
        return mWifi != null && mWifi.isConnectedOrConnecting();
}

En nueva versión de Android

private void getWifiInfo(Context context) {
    ConnectivityManager connManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    Network[] networks = connManager.getAllNetworks();

    if(networks == null || networks.length == 0)
        return;

    for( int i = 0; i < networks.length; i++) {
        Network ntk = networks[i];
        NetworkInfo ntkInfo = connManager.getNetworkInfo(ntk);
        if (ntkInfo.getType() == ConnectivityManager.TYPE_WIFI && ntkInfo.isConnected() ) {
            final WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
            final WifiInfo connectionInfo = wifiManager.getConnectionInfo();
            if (connectionInfo != null) {
                // add some code here
            }
        }

    }
}

y agregar premisión también

Similar a la respuesta de @Jason Knight, pero a la manera de Kotlin:

val connManager = getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
val mWifi = connManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI)

if (mWifi.isConnected) {
     // Do whatever
}

Esta es una solución más fácil. Consulte la pregunta sobre desbordamiento de pila Comprobación de Wi-Fi habilitado o no en Android .

PD: No olvide agregar el código al archivo manifest.xml para permitir el permiso. Como se muestra abajo.

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

Tratar

wifiManager.getConnectionInfo().getIpAddress()

Esto devuelve 0 hasta que el dispositivo tenga una conexión utilizable (en mi máquina, un Samsung SM-T280, Android 5.1.1).

Puede activar WIFI si no está activado como se indica a continuación: 1. verifique el estado de WIFI según lo respondió @Jason Knight 2. si no está activado, actívelo, no olvide agregar el permiso de WIFI en el archivo de manifiesto

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

Tu clase de Java debería ser así

public class TestApp extends Activity {
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);

    //check WIFI activation
    ConnectivityManager connManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo mWifi = connManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);

    if (mWifi.isConnected() == false) {
        showWIFIDisabledAlertToUser();
    }
    else {
        Toast.makeText(this, "WIFI is Enabled in your devide", Toast.LENGTH_SHORT).show();
    }
}


private void showWIFIDisabledAlertToUser(){
    AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(this);
    alertDialogBuilder.setMessage("WIFI is disabled in your device. Would you like to enable it?")
            .setCancelable(false)
            .setPositiveButton("Goto Settings Page To Enable WIFI",
                    new DialogInterface.OnClickListener(){
                        public void onClick(DialogInterface dialog, int id){
                            Intent callGPSSettingIntent = new Intent(
                                    Settings.ACTION_WIFI_SETTINGS);
                            startActivity(callGPSSettingIntent);
                        }
                    });
    alertDialogBuilder.setNegativeButton("Cancel",
            new DialogInterface.OnClickListener(){
                public void onClick(DialogInterface dialog, int id){
                    dialog.cancel();
                }
            });
    AlertDialog alert = alertDialogBuilder.create();
    alert.show();
}

}

Agregue esto para JAVA:

public boolean CheckWifiConnection() {
        ConnectivityManager conMgr = (ConnectivityManager) getSystemService (Context.CONNECTIVITY_SERVICE);
        if (conMgr.getActiveNetworkInfo() != null
                && conMgr.getActiveNetworkInfo().isAvailable()
                && conMgr.getActiveNetworkInfo().isConnected()) {
            return true;
        } else {
            return false;
        }
    }

en el archivo de manifiesto agregue los siguientes permisos:

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

Una vieja pregunta, pero esto es lo que uso. requiere una API mínima, el nivel 21 también tiene en cuenta las API de Networkinfo en desuso.

boolean isWifiConn = false;
    ConnectivityManager connMgr = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        Network network = connMgr.getActiveNetwork();
        if (network == null) return false;
        NetworkCapabilities capabilities = connMgr.getNetworkCapabilities(network);
        if(capabilities != null && capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)){
            isWifiConn = true;
            Toast.makeText(context,"Wifi connected Api >= "+Build.VERSION_CODES.M,Toast.LENGTH_LONG).show();
        }else{
            Toast.makeText(context,"Wifi not connected Api >= "+Build.VERSION_CODES.M,Toast.LENGTH_LONG).show();
        }
    } else {
        for (Network network : connMgr.getAllNetworks()) {
            NetworkInfo networkInfo = connMgr.getNetworkInfo(network);
            if (networkInfo.getType() == ConnectivityManager.TYPE_WIFI && networkInfo.isConnected()) {
                isWifiConn = true;
                Toast.makeText(context,"Wifi connected ",Toast.LENGTH_LONG).show();
                break;
            }else{
                Toast.makeText(context,"Wifi not connected ",Toast.LENGTH_LONG).show();
            }
        }
    }
    return isWifiConn;