Comment savoir si le Wi-Fi est connecté sur Android?

Je ne veux pas que mon utilisateur essaie même de télécharger quelque chose à moins qu'il n'ait une connexion Wi-Fi. Cependant, je peux seulement sembler être en mesure de dire si le Wi-Fi est activé, mais ils pourraient toujours avoir une connexion 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;
}

Cependant, l'État n'est pas ce à quoi je m'attendrais. Même si le Wi-Fi est connecté, je reçois OBTAINING_IPADDRl'état.

Vous devriez pouvoir utiliser ConnectivityManager pour obtenir l'état de l'adaptateur Wi-Fi. De là, vous pouvez vérifier s'il est connecté ou même disponible .

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

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

REMARQUE: Il convient de noter (pour nous n00bies ici) que vous devez ajouter

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

à ton

AndroidManifest.xml pour que cela fonctionne.

NOTE2 : public NetworkInfo getNetworkInfo (int networkType)est désormais obsolète:

Cette méthode était obsolète au niveau de l'API 23. Cette méthode ne prend pas en charge plusieurs réseaux connectés du même type. Utilisez plutôt getAllNetworks () et getNetworkInfo (android.net.Network).

NOTE3 : public static final int TYPE_WIFIest désormais obsolète:

Cette constante était déconseillée au niveau de l'API 28. Les applications devraient plutôt utiliser NetworkCapabilities.hasTransport (int) ou requestNetwork (NetworkRequest, NetworkCallback) pour demander un réseau approprié. pour les transports pris en charge.

Étant donné que la méthode NetworkInfo.isConnected () est désormais déconseillée dans l' API-23 , voici une méthode qui détecte si l'adaptateur Wi-Fi est activé et également connecté à un point d'accès à l'aide de WifiManager à la place:

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

J'utilise simplement ce qui suit:

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

Qui renverra l'un de ces états au moment où vous appelez getSupplicantState ();

ASSOCIÉ - Association terminée.

ASSOCIATING - Essayer de s'associer à un point d'accès.

TERMINÉ - Toute l'authentification est terminée.

DÉCONNECTÉ - Cet état indique que le client n'est pas associé, mais qu'il est susceptible de commencer à rechercher un point d'accès.

DORMANT - Un état ajouté par Android qui est signalé lorsqu'un client émet une commande DISCONNECT explicite.

FOUR_WAY_HANDSHAKE - Prise de contact à clé quadridirectionnelle WPA en cours.

GROUP_HANDSHAKE - Prise de contact par clé de groupe WPA en cours.

INACTIF - État inactif.

INVALIDE - Un pseudo-état qui ne devrait normalement jamais être vu.

NUMÉRISATION - Recherche d'un réseau.

NON INITIALISÉ - Aucune connexion.

J'utilise ceci dans mes applications pour vérifier si le réseau actif est 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

}

J'ai jeté un coup d'œil à quelques questions comme celle-ci et j'ai trouvé ceci:

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
}

J'utilise if pour ma vérification de licence dans Root Toolbox PRO, et cela semble très bien fonctionner.

Bien que la réponse de Jason soit correcte, getNetWorkInfo (int) est aujourd'hui une méthode déconseillée. Donc, la fonction suivante serait une bonne 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;
}

En utilisant WifiManagervous pouvez faire:

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

La méthode getNeworkId renvoie -1 uniquement lorsqu'il n'est pas connecté à un réseau;

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

Le code suivant (dans Kotlin) fonctionne de l'API 21 jusqu'à au moins la version actuelle de l'API (API 29). La fonction getWifiState () renvoie l'une des 3 valeurs possibles pour l'état du réseau WiFi: Disable, EnabledNotConnected et Connected qui ont été définies dans une classe enum. Cela permet de prendre des décisions plus granulaires comme informer l'utilisateur d'activer le WiFi ou, s'il est déjà activé, de se connecter à l'un des réseaux disponibles. Mais si tout ce qui est nécessaire est un booléen indiquant si l'interface WiFi est connectée à un réseau, alors l'autre fonction isWifiConnected () vous le donnera. Il utilise le précédent et compare le résultat à Connecté.

Il s'inspire de certaines des réponses précédentes mais essaie de résoudre les problèmes introduits par l'évolution des API Android ou la disponibilité lentement croissante d'IP V6. L'astuce consistait à utiliser:

wifiManager.connectionInfo.bssid != null 

au lieu de:

1. getIpAddress () == 0 qui n'est valide que pour IP V4 ou
2. getNetworkId () == -1 qui nécessite désormais une autre autorisation spéciale (Location)

Selon la documentation: https://developer.android.com/reference/kotlin/android/net/wifi/WifiInfo.html#getbssid, il retournera null s'il n'est pas connecté à un réseau. Et même si nous n'avons pas la permission d'obtenir la valeur réelle, cela retournera toujours quelque chose d'autre que null si nous sommes connectés.

Gardez également à l'esprit les points suivants:

Sur les versions antérieures à android.os.Build.VERSION_CODES # N, cet objet ne doit être obtenu qu'à partir d'un contexte # getApplicationContext (), et non à partir d'un autre contexte dérivé pour éviter les fuites de mémoire dans le processus appelant.

Dans le manifeste, n'oubliez pas d'ajouter:

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

Le code proposé est:

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 NetworkInfoclasse est obsolète à partir du niveau 29 de l'API, ainsi que les méthodes d'accès associées telles que ConnectivityManager#getNetworkInfo()et ConnectivityManager#getActiveNetworkInfo().

La documentation suggère désormais aux utilisateurs d'utiliser l' ConnectivityManager.NetworkCallbackAPI pour la surveillance des rappels asynchronisés, ou d'utiliser ConnectivityManager#getNetworkCapabilitiesou ConnectivityManager#getLinkPropertiespour un accès synchronisé aux informations réseau

Les appelants doivent plutôt utiliser l'API ConnectivityManager.NetworkCallback pour en savoir plus sur les changements de connectivité, ou basculer pour utiliser ConnectivityManager # getNetworkCapabilities ou ConnectivityManager # getLinkProperties pour obtenir des informations de manière synchrone.

Pour vérifier si le WiFi est connecté, voici le code que j'utilise:

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

N'oubliez pas d'ajouter également l'autorisation ACCESS_NETWORK_STATEà votre fichier manifeste.

Essayez cette méthode.

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

Cette méthode vous aidera à trouver une connexion Internet disponible ou non.

Cela fonctionne pour moi:

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

Et ajoutez cette autorisation:

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

De nombreuses réponses utilisent du code obsolète ou du code disponible sur les versions de l'API higer. Maintenant j'utilise quelque chose comme ça

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;

Voici ce que j'utilise comme méthode utilitaire dans mes applications:

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

Dans la nouvelle 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
            }
        }

    }
}

et ajouter la prémission aussi

Similaire à la réponse de @Jason Knight, mais à la manière de Kotlin:

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

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

C'est une solution plus simple. Voir la question de dépassement de la pile Vérification du Wi-Fi activé ou non sur Android .

PS N'oubliez pas d'ajouter le code au fichier manifest.xml pour autoriser l'autorisation. Comme indiqué ci-dessous.

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

Essayer

wifiManager.getConnectionInfo().getIpAddress()

Cela renvoie 0 jusqu'à ce que l'appareil dispose d'une connexion utilisable (sur ma machine, un Samsung SM-T280, Android 5.1.1).

Vous pouvez activer le WIFI s'il n'est pas activé comme suit 1. vérifiez l'état WIFI comme répondu par @Jason Knight 2. s'il n'est pas activé, activez-le n'oubliez pas d'ajouter la permission WIFI dans le fichier manifeste

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

Votre classe Java devrait être comme ça

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

}

Ajoutez ceci pour 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;
        }
    }

dans le fichier manifeste, ajoutez les autorisations suivantes:

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

Un peu une vieille question mais c'est ce que j'utilise. nécessite une API minimale de niveau 21 prend également en compte les API Networkinfo obsolètes.

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;