Jak sprawdzić, czy Wi-Fi jest podłączony do Androida?

Nie chcę, aby mój użytkownik nawet próbował coś pobrać, chyba że ma połączenie Wi-Fi. Wydaje mi się jednak, że jestem w stanie stwierdzić, czy Wi-Fi jest włączone, ale nadal mogą mieć połączenie 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;
}

Jednak państwo nie jest tym, czego bym się spodziewał. Mimo, że Wi-Fi jest podłączone, dostaję OBTAINING_IPADDRstan.

Powinieneś być w stanie użyć ConnectivityManager, aby uzyskać stan karty Wi-Fi. Stamtąd możesz sprawdzić, czy jest on podłączony, czy nawet dostępny .

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

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

UWAGA: Należy zauważyć (dla nas, tutaj), że należy dodać

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

dla Twojej

AndroidManifest.xml, aby to działało.

UWAGA 2 : public NetworkInfo getNetworkInfo (int networkType)jest już nieaktualny:

Ta metoda została wycofana z poziomu interfejsu API 23. Ta metoda nie obsługuje wielu połączonych sieci tego samego typu. Zamiast tego użyj getAllNetworks () i getNetworkInfo (android.net.Network).

UWAGA 3 : public static final int TYPE_WIFIjest już nieaktualny:

Ta stała została uznana za przestarzałą na poziomie API 28. Aplikacje powinny zamiast tego używać NetworkCapabilities.hasTransport (int) lub requestNetwork (NetworkRequest, NetworkCallback), aby zażądać odpowiedniej sieci. dla obsługiwanych transportów.

Ponieważ metoda NetworkInfo.isConnected () jest teraz przestarzała w API-23 , oto metoda, która wykrywa, czy karta Wi-Fi jest włączona, a także podłączona do punktu dostępu za pomocą WifiManager zamiast:

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

Po prostu używam następujących:

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

Który zwróci jeden z tych stanów w momencie wywołania getSupplicantState ();

STOWARZYSZONE - Stowarzyszenie zakończone.

STOWARZYSZENIE - próba skojarzenia z punktem dostępu.

ZAKOŃCZONE - Całe uwierzytelnianie zakończone.

ODŁĄCZONE - Ten stan wskazuje, że klient nie jest powiązany, ale prawdopodobnie zacznie szukać punktu dostępu.

DORMANT - stan dodany do systemu Android, który jest zgłaszany, gdy klient wydaje jawne polecenie DISCONNECT.

FOUR_WAY_HANDSHAKE - Trwa uzgadnianie 4-kierunkowego klucza WPA.

GROUP_HANDSHAKE - Trwa uzgadnianie klucza grupy WPA.

NIEAKTYWNE - Stan nieaktywny.

NIEPRAWIDŁOWY - pseudo-stan, który normalnie nigdy nie powinien być widoczny.

SKANOWANIE - Skanowanie w poszukiwaniu sieci.

UNINITIALIZED - Brak połączenia.

Używam tego w swoich aplikacjach, aby sprawdzić, czy aktywną siecią jest 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

}

Rzuciłem okiem na kilka takich pytań i wpadłem na to:

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
}

Używam if do sprawdzenia licencji w Root Toolbox PRO i wydaje się, że działa świetnie.

Chociaż odpowiedź Jasona jest poprawna, obecnie getNetWorkInfo (int) jest przestarzałą metodą. Zatem następna funkcja byłaby miłą alternatywą:

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

Za pomocą WifiManagermożesz zrobić:

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

Metoda getNeworkId zwraca -1 tylko wtedy, gdy nie jest podłączona do sieci;

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

Poniższy kod (w Kotlinie) działa od API 21 do co najmniej bieżącej wersji API (API 29). Funkcja getWifiState () zwraca jedną z 3 możliwych wartości stanu sieci Wi-Fi: Disable, EnabledNotConnected i Connected, które zostały zdefiniowane w klasie enum. Umożliwia to podejmowanie bardziej szczegółowych decyzji, takich jak poinformowanie użytkownika o włączeniu Wi-Fi lub, jeśli jest już włączone, o połączeniu się z jedną z dostępnych sieci. Ale jeśli wszystko, co jest potrzebne, to wartość logiczna wskazująca, czy interfejs WiFi jest podłączony do sieci, wtedy inna funkcja isWifiConnected () da ci to. Wykorzystuje poprzedni i porównuje wynik z połączonym.

Jest inspirowany niektórymi wcześniejszymi odpowiedziami, ale próbuje rozwiązać problemy związane z ewolucją interfejsów API Androida lub powoli rosnącą dostępnością IP V6. Sztuką było użycie:

wifiManager.connectionInfo.bssid != null 

zamiast:

1. getIpAddress () == 0, który jest poprawny tylko dla IP V4 lub
2. getNetworkId () == -1, który wymaga teraz innego specjalnego uprawnienia (lokalizacja)

Zgodnie z dokumentacją: https://developer.android.com/reference/kotlin/android/net/wifi/WifiInfo.html#getbssid zwróci wartość null, jeśli nie zostanie podłączony do sieci. I nawet jeśli nie mamy pozwolenia na uzyskanie rzeczywistej wartości, nadal będzie zwracać coś innego niż zero, jeśli będziemy połączeni.

Pamiętaj również o następujących kwestiach:

W wersjach wcześniejszych niż android.os.Build.VERSION_CODES # N ten obiekt należy uzyskać tylko z Context # getApplicationContext (), a nie z żadnego innego kontekstu pochodnego, aby uniknąć wycieków pamięci w procesie wywoływania.

W Manifeście nie zapomnij dodać:

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

Proponowany kod to:

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

NetworkInfoKlasa jest przestarzałe jak API poziomu 29, wraz z powiązanymi metod dostępu, jak ConnectivityManager#getNetworkInfo()i ConnectivityManager#getActiveNetworkInfo().

Dokumentacja teraz sugeruje ludzi do korzystania z ConnectivityManager.NetworkCallbackAPI dla monitorowania niesynchroniczne zwrotnej lub wykorzystania ConnectivityManager#getNetworkCapabilitieslub ConnectivityManager#getLinkPropertiesdo zsynchronizowanego dostępu informacji o sieci

Dzwoniący powinni zamiast tego użyć interfejsu API ConnectivityManager.NetworkCallback, aby dowiedzieć się o zmianach łączności, lub przejść do korzystania z ConnectivityManager # getNetworkCapabilities lub ConnectivityManager # getLinkProperties, aby uzyskać informacje synchronicznie.

Aby sprawdzić, czy WiFi jest podłączone, oto kod, którego używam:

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
}

Jawa:

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

Pamiętaj, aby również dodać uprawnienia ACCESS_NETWORK_STATEdo pliku manifestu.

Wypróbuj tę metodę.

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

Ta metoda pomoże znaleźć połączenie internetowe dostępne lub nie.

To działa dla mnie:

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

I dodaj to uprawnienie:

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

Wiele odpowiedzi używa przestarzałego kodu lub kodu dostępnego w wyższych wersjach API. Teraz używam czegoś takiego

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;

Oto, czego używam jako metody narzędzia w moich aplikacjach:

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

W nowej wersji Androida

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

    }
}

i dodaj też premię

Podobne do odpowiedzi @Jason Knight, ale w sposób Kotlina:

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

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

To jest łatwiejsze rozwiązanie. Zobacz pytanie Przepełnienie stosu Sprawdzanie Wi-Fi włączonego lub nie w systemie Android .

PS Nie zapomnij dodać kodu do pliku manifest.xml, aby zezwolić na pozwolenie. Jak pokazano niżej.

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

Próbować

wifiManager.getConnectionInfo().getIpAddress()

Zwraca 0, dopóki urządzenie nie będzie mieć dostępnego połączenia (na moim komputerze, Samsung SM-T280, Android 5.1.1).

Możesz włączyć WIFI, jeśli nie jest aktywowane w następujący sposób: 1. sprawdź stan WIFI zgodnie z odpowiedzią @Jason Knight 2. jeśli nie jest aktywowany, aktywuj go, nie zapomnij dodać uprawnienia WIFI do pliku manifestu

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

Twoja klasa Java powinna być taka

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

}

Dodaj to dla 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;
        }
    }

w pliku manifestu dodaj następujące uprawnienia:

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

To trochę stare pytanie, ale tego właśnie używam. wymaga poziomu min api 21, bierze również pod uwagę przestarzałe Networkinfo apis.

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;