Come posso vedere se il Wi-Fi è connesso su Android?


237

Non voglio che il mio utente provi nemmeno a scaricare qualcosa a meno che non abbia la connessione Wi-Fi. Tuttavia, posso solo essere in grado di dire se il Wi-Fi è abilitato, ma potrebbero comunque avere una connessione 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;
}

Tuttavia, lo stato non è quello che mi aspetterei. Anche se il Wi-Fi è collegato, sto diventando OBTAINING_IPADDRlo stato.

Risposte:


463

Dovresti essere in grado di utilizzare ConnectivityManager per ottenere lo stato dell'adattatore Wi-Fi. Da lì puoi verificare se è collegato o addirittura disponibile .

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

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

NOTA: Va notato (per noi n00bies qui) che è necessario aggiungere

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

alla tua

AndroidManifest.xml affinché funzioni.

NOTA2 : public NetworkInfo getNetworkInfo (int networkType)è ora obsoleto:

Questo metodo è stato deprecato a livello di API 23. Questo metodo non supporta più reti connesse dello stesso tipo. Utilizzare invece getAllNetworks () e getNetworkInfo (android.net.Network).

NOTA 3 : public static final int TYPE_WIFIè ora obsoleto:

Questa costante è stata deprecata nel livello API 28. Le applicazioni dovrebbero invece utilizzare NetworkCapabilities.hasTransport (int) o requestNetwork (NetworkRequest, NetworkCallback) per richiedere una rete appropriata. per i trasporti supportati.


72
Va notato (per noi noobies qui) che è necessario aggiungere android.permission.ACCESS_NETWORK_STATEal tuo AndroidManifest.xml per farlo funzionare.
mgalgs,

10
Nelle versioni molto recenti di Android, devi controllare NULL in mWiFi ... il tuo codice qui potrebbe generare un errore puntatore nullo. Vedi developer.android.com/training/basics/network-ops/managing.html e in particolare "Il metodo getActiveNetworkInfo () restituisce un NetworkInfo ..."
eb80,

1
Ha funzionato anche per me con l'interfaccia Ethernet. Sono appena passato a ConnectivityManager.TYPE_ETHERNET
MBH il

3
Il metodo NetworkInfo.isConnected () è ora obsoleto in API-23. Sto pubblicando una soluzione di seguito.
rivoluzionario

1
NetworkInfo.getType () e ConnectivityManager.TYPE_WIFI sono ora deprecati nell'API 28. Per evitare avvertimenti sui lanugine dovresti usare qualcosa di simileconnectivityManager.getNetworkCapabilities(network).hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
Vadik,

75

Poiché il metodo NetworkInfo.isConnected () è ora deprecato in API-23 , ecco un metodo che rileva se l'adattatore Wi-Fi è attivo e anche connesso a un punto di accesso usando WifiManager invece:

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

4
Vale la pena ricordare che wifiInfo può essere null quindi penso che dovresti controllare null prima di ottenere l'ID di rete
Nonos

2
NetworkInfo.isConnected()non mi sembra deprecato.
EricRobertBrewer

Non dimenticare di aggiungere l'autorizzazione:android.permission.ACCESS_WIFI_STATE
Ton Snoei

1
Questo non funzionerà più in Android Q senza l'autorizzazione della posizione e la modalità di localizzazione attivate, vedi issuetracker.google.com/issues/136021574 .
Konsumierer,

Il commento di @EricRobertBrewer non è più aggiornato. è ora, API obsoleta 29+.
NuKs

35

Uso semplicemente quanto segue:

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

Che restituirà uno di questi stati al momento della chiamata getSupplicantState ();

ASSOCIATO - Associazione completata.

ASSOCIAZIONE - Cercare di associarsi a un punto di accesso.

COMPLETATO - Tutte le autenticazioni completate.

DISCONNESSO - Questo stato indica che il client non è associato, ma è probabile che inizi a cercare un punto di accesso.

DORMANTE - Uno stato aggiunto da Android che viene segnalato quando un client emette un comando DISCONNECT esplicito.

FOUR_WAY_HANDSHAKE - Handshake chiave a 4 vie WPA in corso.

GROUP_HANDSHAKE: stretta di mano della chiave di gruppo WPA in corso.

INATTIVO - Stato inattivo.

INVALIDO - Uno pseudo-stato che normalmente non dovrebbe mai essere visto.

SCANSIONE - Scansione per una rete.

NONINIZIALIZZATO - Nessuna connessione.


ciao Donal. Ho usato lo stesso modo per sapere se il nostro dispositivo è connesso al wifi, ma devo anche sapere il nome dell'app che attualmente utilizza WIFI.
AbhishekB,

@AbhishekB, scusa ma non ho alcuna esperienza in merito, forse prova ad esaminare alcune delle app di monitoraggio Wi-Fi, vedi se ce n'è una open source in cui puoi rivedere il codice.
Donal Rafferty,

Sono sospettoso di questa soluzione perché il supplicant viene utilizzato solo se viene utilizzato WPA (o qualche variante di WPA) d: se l'utente si connette a un AP senza autenticazione o WEP, il supplicant non è coinvolto.
Tom,

2
Viene ancora visualizzato come "COMPLETATO" anche se non sono in wifi
Evan Parsons,

1
esiste qualche intento di trasmissione del sistema per gli stati sopra menzionati? @DonalRafferty
Rohit Singh

19

Lo sto usando nelle mie app per verificare se la rete attiva è 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

}

Questa è la risposta migliore perché si assicura che la activerete (quella che verrà utilizzata per il download) sia WiFi
Gavriel,

1
È anche la risposta migliore ora che NetworkInfo#isConnectedè deprecata
Tash Pemhiwa,

Sicuramente la migliore risposta per quest'anno (2017).
Daniel Nugent,

18

Ho dato un'occhiata ad alcune domande come questa e ho pensato a questo:

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
}

Uso se per il mio controllo della licenza in Root Toolbox PRO, e sembra funzionare alla grande.


8
sembra buono ma non sono sicuro del motivo per cui si ottiene un secondo riferimento a ConnectivityManager. In questo esempio connManager e connManager1 sono entrambi lo stesso oggetto
Nathan Schwermann

1
TYPE_MOBLIE significa 3gnet o gprs net?
herbertD

1
TYPE_MOBILE indica qualsiasi dato che utilizza il tuo operatore: 2G (GPRS ...), 3G (HSDPA ...) o 4G (LTE ...).
Eugen Pechanec,

1
puoi aggiungere TYPE_ETHERNET che ha funzionato bene quando hai collegato android a Ethernet
MBH il

1
Vale la pena tenere presente che getNetworkInfo()restituirà un valore nullo se la rete non esiste. Quindi, se il dispositivo non ha una connessione mobile, verrà generato un errore. Nella maggior parte dei casi, TYPE_ETHERNET causerà un null in questo caso, poiché la maggior parte dei dispositivi non avrà una connessione Ethernet.
Cnosso,

7

Mentre la risposta di Jason è corretta, oggigiorno getNetWorkInfo (int) è un metodo deprecato. Quindi, la prossima funzione sarebbe una bella 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;
}

3

Usando WifiManagerpuoi fare:

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

Il metodo getNeworkId restituisce -1 solo quando non è connesso a una rete;


WIFI_STATE_DISABLED Costante Valore: 1 (0x00000001) WIFI_STATE_DISABLING Costante Valore: 0 (0x00000000) WIFI_STATE_ENABLED Costante Valore: 3 (0x00000003) WIFI_STATE_ENABLING Costante Valore: 2 (0x00000002) WIFI_STATE_UNKNOWN Costante Valore: 4 (0x00000004)
Lou Morda


Questo non funzionerà più in Android Q senza l'autorizzazione della posizione e la modalità di localizzazione attivate, vedi 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;
}

1
sarebbe meglio aggiungere qualche spiegazione piuttosto che solo il codice.
EdChum,

2
Vorrei usare isConnected () , i documenti dicono: boolean isConnectedOrConnecting ()Indica se la connettività di rete esiste o è in fase di definizione. Questo è utile per le applicazioni che devono fare qualsiasi cosa relativa alla rete oltre a leggere o scrivere dati. Per quest'ultimo, chiama isConnected()invece, il che garantisce che la rete sia completamente utilizzabile.
18446744073709551615

3

Il seguente codice (in Kotlin) funziona dall'API 21 fino almeno alla versione API corrente (API 29). La funzione getWifiState () restituisce uno dei 3 possibili valori per lo stato della rete WiFi: Disable, EnabledNotConnected e Connected definiti in una classe enum. Ciò consente di prendere decisioni più dettagliate come informare l'utente per abilitare il WiFi o, se già abilitato, connettersi a una delle reti disponibili. Ma se tutto ciò che serve è un valore booleano che indica se l'interfaccia WiFi è connessa a una rete, allora l'altra funzione isWifiConnected () ti darà questo. Utilizza il precedente e confronta il risultato con Connected.

È ispirato in alcune delle risposte precedenti ma cerca di risolvere i problemi introdotti dall'evoluzione delle API di Android o dalla disponibilità lentamente crescente di IP V6. Il trucco era usare:

wifiManager.connectionInfo.bssid != null 

invece di:

  1. getIpAddress () == 0 valido solo per IP V4 o
  2. getNetworkId () == -1 che ora richiede un'altra autorizzazione speciale (Posizione)

Secondo la documentazione: https://developer.android.com/reference/kotlin/android/net/wifi/WifiInfo.html#getbssid restituirà null se non connesso a una rete. E anche se non abbiamo l'autorizzazione per ottenere il valore reale, restituirà comunque qualcosa di diverso da null se siamo connessi.

Tieni anche presente quanto segue:

Nelle versioni precedenti a android.os.Build.VERSION_CODES # N, questo oggetto deve essere ottenuto solo da un contesto # getApplicationContext () e non da qualsiasi altro contesto derivato per evitare perdite di memoria nel processo di chiamata.

Nel Manifest, non dimenticare di aggiungere:

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

Il codice proposto è:

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

3

La NetworkInfoclasse è obsoleta a partire dal livello API 29, insieme ai relativi metodi di accesso come ConnectivityManager#getNetworkInfo()e ConnectivityManager#getActiveNetworkInfo().

La documentazione ora suggerisce alle persone di utilizzare l' ConnectivityManager.NetworkCallbackAPI per il monitoraggio della richiamata asincrona o di utilizzare ConnectivityManager#getNetworkCapabilitieso ConnectivityManager#getLinkPropertiesper l'accesso sincronizzato delle informazioni di rete

I chiamanti dovrebbero invece utilizzare l'API ConnectivityManager.NetworkCallback per conoscere le modifiche alla connettività o passare a utilizzare ConnectivityManager # getNetworkCapabilities o ConnectivityManager # getLinkProperties per ottenere informazioni in modo sincrono.


Per verificare se il WiFi è collegato, ecco il codice che utilizzo:

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
}

Giava:

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

Ricorda di aggiungere anche l'autorizzazione ACCESS_NETWORK_STATEal tuo file manifest.


2

Prova questo metodo.

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

Questo metodo aiuterà a trovare la connessione Internet disponibile o meno.


1
Stavo cercando specificamente se la connessione attiva è il wifi. Inoltre, non è necessario eseguire un controllo nullo su conMgr e non sarà mai nullo.
Nathan Schwermann,

Puoi controllare questa domanda per favore? :(
Skizo-ozᴉʞS

2

Questo funziona per me:

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

E aggiungi questa autorizzazione:

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

2

Molte risposte utilizzano codice obsoleto o codice disponibile nelle versioni API di higer. Adesso uso qualcosa del genere

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;

1

Ecco cosa uso come metodo di utilità nelle mie app:

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

È bene sottolineare che il metodo isConnectedOrConnecting è importante quando si verifica la connessione stabilita. Il metodo IsConnected non ha funzionato per me.
vincent,

1

Nella nuova versione 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
            }
        }

    }
}

e aggiungi anche la premissione


connManager.getAllNetworks()richiede il livello API 21.
Jawand Singh

1

Simile alla risposta di @Jason Knight, ma alla maniera di Kotlin:

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

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

ConnectivityManager.TYPE_WIFIè deprecato
Jérôme Pietri

0

Questa è una soluzione più semplice. Vedi domanda Stack Overflow Verifica Wi-Fi abilitato o meno su Android .

PS Non dimenticare di aggiungere il codice al file manifest.xml per consentire l'autorizzazione. Come mostrato di seguito.

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

0

Provare

wifiManager.getConnectionInfo().getIpAddress()

Questo restituisce 0 fino a quando il dispositivo ha una connessione utilizzabile (sulla mia macchina, un Samsung SM-T280, Android 5.1.1).


0

È possibile attivare il WIFI se non è attivato come segue 1. controllare lo stato WIFI come indicato da @Jason Knight 2. se non attivato, attivarlo non dimenticare di aggiungere l'autorizzazione WIFI nel file manifest

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

La tua classe Java dovrebbe essere così

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

}


0

Aggiungi questo per 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;
        }
    }

nel file manifest aggiungere le seguenti autorizzazioni:

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

0

Una specie di vecchia domanda, ma questo è quello che uso. richiede un livello minimo di API 21 prende in considerazione anche le API obsolete di Networkinfo.

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;
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.