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

237

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.

Nathan Schwermann
fuente

Respuestas:

463

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.

Jason Knight
fuente
72
Cabe señalar (para nosotros novatos aquí) que debe agregar android.permission.ACCESS_NETWORK_STATEa su AndroidManifest.xml para que esto funcione.
mgalgs
10
En versiones muy recientes de Android, debe verificar NULL en mWiFi ... su código aquí podría arrojar un error de puntero nulo. Consulte developer.android.com/training/basics/network-ops/managing.html y, en particular, "El método getActiveNetworkInfo () devuelve un NetworkInfo ..."
eb80
1
A mí también me funcionó con la interfaz Ethernet. Acabo de cambiar a ConnectivityManager.TYPE_ETHERNET
MBH
3
El método NetworkInfo.isConnected () ahora está desactualizado en API-23. Estoy publicando una solución a continuación.
revolucionario
1
NetworkInfo.getType () y ConnectivityManager.TYPE_WIFI ahora están en desuso en la API 28. Para evitar advertencias sobre pelusas, debe usar algo comoconnectivityManager.getNetworkCapabilities(network).hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
Vadik
75

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
    }
}
revolucionario
fuente
44
Vale la pena mencionar que wifiInfo puede ser nulo, así que creo que usted debe comprobar NULL antes de obtener ID de red
Nonos
2
NetworkInfo.isConnected()no me parece obsoleto
EricRobertBrewer
No olvides agregar permiso:android.permission.ACCESS_WIFI_STATE
Ton Snoei
1
Esto ya no funcionará en Android Q sin permiso de ubicación y el modo de ubicación activado, consulte issuetracker.google.com/issues/136021574 .
Konsumierer
El comentario de @EricRobertBrewer ya no está actualizado. ahora está en desuso API 29+.
nuKs
35

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.

Donal Rafferty
fuente
hola Donal. He utilizado la misma forma para saber si nuestro dispositivo está conectado a wifi. Pero, además, necesito saber el nombre de la aplicación que actualmente usa WIFI. ¿Cómo puedo hacerlo?
AbhishekB
@AbhishekB, lo siento, pero no tengo experiencia con eso, tal vez intente mirar algunas de las aplicaciones de monitoreo de Wi-Fi, vea si hay una fuente de código abierto donde pueda revisar el código.
Donal Rafferty
Sospecho de esta solución porque el solicitante solo se usa si se usa WPA (o alguna variación de WPA): si el usuario se conecta a un AP sin autenticación o WEP, el solicitante no está involucrado.
Tom
2
Todavía aparece como "COMPLETADO" aunque no estoy en wifi
Evan Parsons
1
¿Hay alguna intención de transmisión del sistema para los estados mencionados anteriormente? @DonalRafferty
Rohit Singh
19

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

}
kuchi
fuente
Esta es la mejor respuesta porque se asegura de que la activered (la que se utilizará para descargar) sea WiFi
Gavriel
1
También es la mejor respuesta ahora que NetworkInfo#isConnectedestá en desuso
Tash Pemhiwa
Definitivamente la mejor respuesta para este año (2017).
Daniel Nugent
18

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.

Movimiento de lucas
fuente
8
se ve bien, pero no estoy seguro de por qué obtienes una segunda referencia a ConnectivityManager. En este ejemplo, connManager y connManager1 son el mismo objeto
Nathan Schwermann el
1
¿TYPE_MOBLIE significa 3gnet o gprs net?
herbertD
1
TYPE_MOBILE se refiere a cualquier información que use su operador: 2G (GPRS ...), 3G (HSDPA ...) o 4G (LTE ...).
Eugen Pechanec
1
puede agregar TYPE_ETHERNET que funcionó bien al conectar Android a Ethernet
MBH
1
Vale la pena tener en cuenta que getNetworkInfo()devolverá un valor nulo si la red no existe. Entonces, si el dispositivo no tiene conexión móvil, esto arrojará un error. En la mayoría de los casos, TYPE_ETHERNET causará un nulo en este caso, ya que la mayoría de los dispositivos no tendrán una conexión Ethernet.
Knossos
7

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;
}
Val Martinez
fuente
3

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;

razz
fuente
WIFI_STATE_DISABLED Constante Valor: 1 (0x00000001) WIFI_STATE_DISABLING Constant Valor: 0 (0x00000000) WIFI_STATE_ENABLED Constante Valor: 3 (0x00000003) WIFI_STATE_ENABLING Constante Valor: 2 (0x00000002) WIFI_STATE_UNKNOWN Constante Valor: 4 (0x00000004)
Lou Morda
Esto ya no funcionará en Android Q sin permiso de ubicación y el modo de ubicación activado, consulte issuetracker.google.com/issues/136021574 .
Konsumierer
3
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;
}
GM Ramesh
fuente
1
Sería mejor agregar alguna explicación en lugar de solo código.
EdChum
2
Me gustaría utilizar isConnected () , los documentos dicen: boolean isConnectedOrConnecting ()Indica si existe conectividad de red o está en proceso de ser establecida. Esto es bueno para aplicaciones que necesitan hacer algo relacionado con la red que no sea leer o escribir datos. Para este último, llame en su isConnected()lugar, lo que garantiza que la red sea totalmente utilizable.
18446744073709551615
3

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)
    }
}
DarkJediNinja
fuente
3

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.

jackz314
fuente
2

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.

Maryland
fuente
1
Estaba buscando específicamente si la conexión activa es wifi. Además, no es necesario hacer una verificación nula en conMgr, nunca será nulo.
Nathan Schwermann
¿Puedes revisar esta pregunta por favor? :(
Skizo-ozᴉʞS
2

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" />
Ahmad
fuente
2

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;
Oleg Shevchenko
fuente
1

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();
}
Mahendra Liya
fuente
Es bueno señalar que el método isConnectedOrConnecting es importante cuando verifica el establecimiento de la conexión. El método IsConnected no funcionó para mí.
vincent
1

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

Albert Nguyen
fuente
connManager.getAllNetworks()requiere API nivel 21.
Jawand Singh
1

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
}
Jerry Chong
fuente
ConnectivityManager.TYPE_WIFIestá en desuso
Jérôme Pietri
0

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>
Clayden
fuente
0

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).

Adrian
fuente
0

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

}

Ahmed Belal
fuente
0

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" />
Sagitario
fuente
0

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;
Katwekibs
fuente