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

237

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.

Nathan Schwermann
la source

Réponses:

463

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.

Jason Knight
la source
72
Il convient de noter (pour nous, noobies ici) que vous devez ajouter android.permission.ACCESS_NETWORK_STATEà votre AndroidManifest.xml pour que cela fonctionne.
mgalgs
10
Dans les versions très récentes d'Android, vous devez vérifier la valeur NULL dans mWiFi ... votre code ici pourrait générer une erreur de pointeur nul. Voir developer.android.com/training/basics/network-ops/managing.html et en particulier "La méthode getActiveNetworkInfo () renvoie un NetworkInfo ..."
eb80
1
Cela a également fonctionné pour moi avec l'interface Ethernet. Je viens de passer à ConnectivityManager.TYPE_ETHERNET
MBH
3
La méthode NetworkInfo.isConnected () est désormais obsolète dans l'API-23. Je poste une solution ci-dessous.
révolutionnaire
1
NetworkInfo.getType () et ConnectivityManager.TYPE_WIFI sont désormais obsolètes dans l'API 28. Pour éviter un avertissement de peluches, vous devez utiliser quelque chose commeconnectivityManager.getNetworkCapabilities(network).hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
Vadik
75

É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
    }
}
révolutionnaire
la source
4
Il convient de mentionner que wifiInfo peut être nul, donc je pense que vous devriez vérifier la valeur null avant d'obtenir l'ID réseau
Nonos
2
NetworkInfo.isConnected()ne me semble pas obsolète.
EricRobertBrewer
N'oubliez pas d'ajouter la permission:android.permission.ACCESS_WIFI_STATE
Ton Snoei
1
Cela ne fonctionnera plus dans Android Q sans l'autorisation de localisation et le mode de localisation activé, voir issuetracker.google.com/issues/136021574 .
Konsumierer
Le commentaire @EricRobertBrewer n'est plus à jour. il est désormais obsolète API 29+.
nuKs
35

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.

Donal Rafferty
la source
salut Donal.J'ai utilisé la même manière pour savoir si notre appareil est connecté au wifi.Mais en plus, j'ai besoin de connaître le nom de l'application utilisant actuellement le WIFI.Comment cela peut-il être fait?
AbhishekB
@AbhishekB, désolé mais je n'ai aucune expérience avec cela, essayez peut-être de regarder certaines des applications de surveillance Wi-Fi, voyez s'il y en a une open source où vous pouvez consulter le code.
Donal Rafferty
Je me méfie de cette solution car le demandeur n'est utilisé que si WPA (ou une variante de WPA) est utilisé: si l'utilisateur se connecte à un point d'accès sans authentification ou WEP, le demandeur n'est pas impliqué.
Tom
2
Il apparaît toujours comme "TERMINÉ" même si je ne suis pas sur le wifi
Evan Parsons
1
Y a-t-il une intention de diffusion du système pour les États susmentionnés? @DonalRafferty
Rohit Singh
19

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

}
kuchi
la source
C'est la meilleure réponse car elle garantit que le activeréseau (celui qui sera utilisé pour le téléchargement) est le WiFi
Gavriel
1
C'est aussi la meilleure réponse maintenant NetworkInfo#isConnecteddéconseillée
Tash Pemhiwa
Certainement la meilleure réponse pour cette année (2017).
Daniel Nugent
18

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.

LukeMovement
la source
8
semble bon, mais je ne sais pas pourquoi vous obtenez une deuxième référence à ConnectivityManager. Dans cet exemple, connManager et connManager1 sont tous deux le même objet
Nathan Schwermann
1
TYPE_MOBLIE signifie-t-il 3gnet ou gprs net?
herbertD
1
TYPE_MOBILE signifie toutes les données utilisant votre opérateur - 2G (GPRS ...), 3G (HSDPA ...) ou 4G (LTE ...).
Eugen Pechanec
1
vous pouvez ajouter TYPE_ETHERNET qui a bien fonctionné lors de la connexion d'Android à Ethernet
MBH
1
Il convient de garder à l'esprit que getNetworkInfo()cela retournera une valeur nulle si le réseau n'existe pas. Donc, si l'appareil n'a pas de connexion mobile, cela générera une erreur. Dans la plupart des cas, TYPE_ETHERNET provoquera une valeur nulle dans ce cas, car la plupart des appareils n'auront pas de connexion Ethernet.
Knossos
7

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

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;

razz
la source
WIFI_STATE_DISABLED Constante Valeur: 1 (0x00000001) WIFI_STATE_DISABLING Constant Valeur: 0 (0x00000000) WIFI_STATE_ENABLED Valeur Constante: 3 (0x00000003) WIFI_STATE_ENABLING Constant Valeur 2 (0x00000002) WIFI_STATE_UNKNOWN Constant Valeur: 4 (0x00000004)
Lou Morda
Cela ne fonctionnera plus dans Android Q sans l'autorisation de localisation et le mode de localisation activé, voir 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
la source
1
il serait préférable d'ajouter des explications plutôt que du code.
EdChum
2
J'utiliserais isConnected () , les documents disent: boolean isConnectedOrConnecting ()indique si la connectivité réseau existe ou est en cours d'établissement. C'est bon pour les applications qui ont besoin de faire autre chose que le réseau pour lire ou écrire des données. Pour ces derniers, appelez isConnected()plutôt, ce qui garantit que le réseau est pleinement utilisable.
18446744073709551615
3

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

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.

jackz314
la source
2

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.

MARYLAND
la source
1
Je cherchais spécifiquement si la connexion active est le wifi. De plus, pas besoin de faire une vérification nulle sur conMgr, il ne sera jamais nul.
Nathan Schwermann
Pouvez-vous vérifier cette question s'il vous plaît? :(
Skizo-ozᴉʞS
2

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

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

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();
}
Mahendra Liya
la source
Il est bon de souligner que la méthode isConnectedOrConnecting est importante lorsque vous vérifiez l'établissement de la connexion. La méthode IsConnected ne fonctionnait pas pour moi.
vincent
1

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

Albert Nguyen
la source
connManager.getAllNetworks()nécessite l'API niveau 21.
Jawand Singh
1

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
}
Jerry Chong
la source
ConnectivityManager.TYPE_WIFIest déconseillé
Jérôme Pietri
0

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>
Clayden
la source
0

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

Adrian
la source
0

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

}

Ahmed Belal
la source
0

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" />
Sagittaire
la source
0

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;
katwekibs
la source