Wie sehe ich, ob Wi-Fi unter Android verbunden ist?

Ich möchte nicht, dass mein Benutzer versucht, etwas herunterzuladen, es sei denn, er hat eine Wi-Fi-Verbindung. Ich kann jedoch anscheinend nur feststellen, ob Wi-Fi aktiviert ist, aber sie könnten immer noch eine 3G-Verbindung haben.

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

Der Staat ist jedoch nicht das, was ich erwarten würde. Obwohl Wi-Fi verbunden ist, werde ich OBTAINING_IPADDRals Staat.

Sie sollten den ConnectivityManager verwenden können, um den Status des Wi-Fi-Adapters abzurufen. Von dort aus können Sie überprüfen, ob es angeschlossen oder überhaupt verfügbar ist .

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

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

HINWEIS: Es sollte beachtet werden (für uns n00bies hier), dass Sie hinzufügen müssen

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

zu deinem

AndroidManifest.xml, damit dies funktioniert.

HINWEIS 2 : public NetworkInfo getNetworkInfo (int networkType)ist jetzt veraltet:

Diese Methode wurde in API-Level 23 nicht mehr unterstützt. Diese Methode unterstützt nicht mehrere verbundene Netzwerke desselben Typs. Verwenden Sie stattdessen getAllNetworks () und getNetworkInfo (android.net.Network).

HINWEIS 3 : public static final int TYPE_WIFIist jetzt veraltet:

Diese Konstante wurde in API-Ebene 28 nicht mehr unterstützt. Anwendungen sollten stattdessen NetworkCapabilities.hasTransport (int) oder requestNetwork (NetworkRequest, NetworkCallback) verwenden, um ein geeignetes Netzwerk anzufordern. für unterstützte Transporte.

Da die Methode NetworkInfo.isConnected () in API-23 jetzt veraltet ist, erkennt diese Methode, ob der Wi-Fi-Adapter eingeschaltet ist und stattdessen auch über WifiManager mit einem Zugriffspunkt verbunden ist:

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

Ich benutze einfach folgendes:

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

Was einen dieser Zustände zurückgibt, wenn Sie getSupplicantState () aufrufen;

ASSOCIATED - Verein abgeschlossen.

ASSOCIATING - Es wird versucht, eine Verbindung zu einem Access Point herzustellen.

ABGESCHLOSSEN - Alle Authentifizierung abgeschlossen.

DISCONNECTED - DISCONNECTED - Dieser Status zeigt an, dass der Client nicht zugeordnet ist, aber wahrscheinlich nach einem Zugriffspunkt sucht.

DORMANT - Ein von Android hinzugefügter Status, der gemeldet wird, wenn ein Client einen expliziten Befehl DISCONNECT ausgibt.

FOUR_WAY_HANDSHAKE - WPA 4-Wege-Schlüssel-Handshake läuft.

GROUP_HANDSHAKE - WPA Group Key Handshake wird ausgeführt.

INAKTIV - Inaktiver Zustand.

UNGÜLTIG - Ein Pseudozustand, der normalerweise nie gesehen werden sollte.

SCANNEN - Scannen nach einem Netzwerk.

UNINITIALISIERT - Keine Verbindung.

Ich verwende dies in meinen Apps, um zu überprüfen, ob das aktive Netzwerk Wi-Fi ist:

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

    // Do your work here

}

Ich habe mir ein paar Fragen wie diese angesehen und mir Folgendes ausgedacht:

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
}

Ich verwende if für meine Lizenzprüfung in Root Toolbox PRO und es scheint großartig zu funktionieren.

Während Jasons Antwort richtig ist, ist getNetWorkInfo (int) heutzutage eine veraltete Methode. Die nächste Funktion wäre also eine schöne Alternative:

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

Mit können WifiManagerSie tun:

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

Die Methode getNeworkId gibt -1 nur zurück, wenn sie nicht mit einem Netzwerk verbunden ist.

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

Der folgende Code (in Kotlin) funktioniert von API 21 bis mindestens zur aktuellen API-Version (API 29). Die Funktion getWifiState () gibt einen von drei möglichen Werten für den WiFi-Netzwerkstatus zurück: Disable, EnabledNotConnected und Connected, die in einer Enum-Klasse definiert wurden. Dies ermöglicht detailliertere Entscheidungen, z. B. die Information des Benutzers, WLAN zu aktivieren oder, falls bereits aktiviert, eine Verbindung zu einem der verfügbaren Netzwerke herzustellen. Wenn jedoch nur ein Boolescher Wert benötigt wird, der angibt, ob die WiFi-Schnittstelle mit einem Netzwerk verbunden ist, erhalten Sie die andere Funktion isWifiConnected (). Es verwendet das vorherige und vergleicht das Ergebnis mit Connected.

Es ist inspiriert von einigen der vorherigen Antworten, versucht jedoch, die Probleme zu lösen, die durch die Entwicklung der Android-APIs oder die langsam steigende Verfügbarkeit von IP V6 entstehen. Der Trick war zu verwenden:

wifiManager.connectionInfo.bssid != null 

anstatt:

1. getIpAddress () == 0, die nur für IP V4 oder gültig ist
2. getNetworkId () == -1, für das jetzt eine weitere Sonderberechtigung erforderlich ist (Speicherort)

Gemäß der Dokumentation: https://developer.android.com/reference/kotlin/android/net/wifi/WifiInfo.html#getbssid wird null zurückgegeben, wenn keine Verbindung zu einem Netzwerk besteht. Und selbst wenn wir keine Berechtigung haben, den tatsächlichen Wert abzurufen, wird immer noch etwas anderes als null zurückgegeben, wenn wir verbunden sind.

Beachten Sie auch Folgendes:

Bei Releases vor android.os.Build.VERSION_CODES # N sollte dieses Objekt nur aus einem Context # getApplicationContext () und nicht aus einem anderen abgeleiteten Kontext abgerufen werden, um Speicherverluste innerhalb des aufrufenden Prozesses zu vermeiden.

Vergessen Sie nicht, im Manifest Folgendes hinzuzufügen:

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

Vorgeschlagener Code ist:

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

Die NetworkInfoKlasse ist ab API-Ebene 29 zusammen mit den zugehörigen Zugriffsmethoden wie ConnectivityManager#getNetworkInfo()und veraltet ConnectivityManager#getActiveNetworkInfo().

In der Dokumentation wird nun vorgeschlagen, die ConnectivityManager.NetworkCallbackAPI für die asynchronisierte Rückrufüberwachung ConnectivityManager#getNetworkCapabilitiesoder ConnectivityManager#getLinkPropertiesfür den synchronisierten Zugriff auf Netzwerkinformationen zu verwenden

Anrufer sollten stattdessen die ConnectivityManager.NetworkCallback-API verwenden, um Informationen zu Konnektivitätsänderungen zu erhalten, oder zur Verwendung von ConnectivityManager # getNetworkCapabilities oder ConnectivityManager # getLinkProperties wechseln, um Informationen synchron abzurufen.

Um zu überprüfen, ob WLAN verbunden ist, verwende ich folgenden Code:

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

Denken Sie daran ACCESS_NETWORK_STATE, Ihrer Manifest-Datei auch Berechtigungen hinzuzufügen .

Probieren Sie diese Methode aus.

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

Diese Methode hilft dabei, eine verfügbare Internetverbindung zu finden oder nicht.

Das funktioniert bei mir:

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

Und fügen Sie diese Berechtigung hinzu:

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

Viele Antworten verwenden veralteten Code oder Code, der in höheren API-Versionen verfügbar ist. Jetzt benutze ich so etwas

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;

Folgendes verwende ich als Dienstprogramm in meinen Apps:

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

In der neuen Version 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
            }
        }

    }
}

und füge auch Premission hinzu

Ähnlich wie bei @Jason Knight, aber auf Kotlin-Art:

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

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

Dies ist eine einfachere Lösung. Siehe Frage zum Stapelüberlauf Überprüfen , ob Wi-Fi unter Android aktiviert ist oder nicht .

PS Vergessen Sie nicht, den Code zur Datei manifest.xml hinzuzufügen, um die Berechtigung zuzulassen. Wie nachfolgend dargestellt.

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

Versuchen

wifiManager.getConnectionInfo().getIpAddress()

Dies gibt 0 zurück, bis das Gerät eine verwendbare Verbindung hat (auf meinem Computer ein Samsung SM-T280, Android 5.1.1).

Sie können WIFI aktivieren, wenn es nicht wie folgt aktiviert ist: 1. Überprüfen Sie den WIFI-Status, wie von @Jason Knight beantwortet. 2. Wenn er nicht aktiviert ist, aktivieren Sie ihn. Vergessen Sie nicht, die WIFI-Berechtigung in die Manifestdatei aufzunehmen

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

Ihre Java-Klasse sollte so sein

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

}}

Fügen Sie dies für JAVA hinzu:

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

Fügen Sie in der Manifest-Datei die folgenden Berechtigungen hinzu:

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

Ein bisschen alt eine Frage, aber das ist, was ich benutze. erfordert min api level 21 berücksichtigt auch veraltete 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;