Comment puis-je voir si le Wi-Fi est connecté sur Android?

StackOverflow https://stackoverflow.com/questions/3841317

Question

Je ne veux pas que mon utilisateur d'essayer même de télécharger quelque chose à moins d'avoir connecté Wi-Fi. Cependant, je ne peux pas sembler être en mesure de dire si le Wi-Fi est activé, mais ils pourraient encore 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 est pas ce que j'attendre. Même si une connexion Wi-Fi est connecté, je reçois OBTAINING_IPADDR comme l'état.

Était-ce utile?

La solution

Vous devriez être en mesure d'utiliser le 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" />

à votre

AndroidManifest.xml pour que cela fonctionne.

NOTE2 : public NetworkInfo getNetworkInfo (int networkType) est maintenant dépréciée:

  

Cette méthode a été dépréciée dans le niveau de l'API 23. Cette méthode ne fonctionne pas   soutenir les réseaux connectés multiples du même type. Utilisation   getAllNetworks () et GetNetworkInfo (android.net.Network) à la place.

REMARQUE3 : public static final int TYPE_WIFI est maintenant obsolète:

  

Cette constante a été dépréciée dans le niveau de l'API 28.   Les applications doivent plutôt utiliser NetworkCapabilities.hasTransport (int) ou requestNetwork (NetworkRequest, NetworkCallback) pour demander un réseau approprié. pour le transport en charge.

Autres conseils

Puisque la méthode NetworkInfo.isConnected () est maintenant Obsolète API-23 , voici une méthode qui détecte si le Wi- adaptateur Fi est aussi connecté à un point d'accès à l'aide 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();

Ce qui renverra un de ces états au moment où vous appelez getSupplicantState ();

  

ASSOCIÉS - Association terminée.

     

ASSOCIER - Essayer d'associer   un point d'accès.

     

REMPLI - Tous authentification   terminé.

     

DISCONNECTED - Cet état indique   ce client n'est pas associé, mais   susceptibles de commencer à chercher un accès   point.

     

DORMANT - Un état ajoutée applications que   est signalé lorsqu'un client émet une   explicite commande disconnect.

     

FOUR_WAY_HANDSHAKE - WPA 4-Way Key   Poignée de main en cours.

     

GROUP_HANDSHAKE - WPA clés du Groupe   Poignée de main en cours.

     

INACTIVE -. État inactif

     

VALIDE - Un pseudo-état qui devrait   normalement jamais vu.

     

SCANNER - Numérisation d'un réseau.

     

UNINITIALIZED -. Pas de connexion

J'utilise dans mes applications pour vérifier si le réseau est actif 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 eu un coup d'oeil à quelques questions comme celle-ci et est venu avec 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 si pour mon chèque de licence à Root Toolbox PRO, et il semble grand travail.

Alors que la réponse de Jason est correct, de nos jours GetNetworkInfo (int) est une méthode obsolète. Ainsi, 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;
}

Utilisation WifiManager vous pouvez faire: 

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

La méthode getNeworkId rendements -1 seulement quand il 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;
}

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

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 l'autorisation à

Tout comme réponse Chevalier @ Jason, mais de manière Kotlin: 

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

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

Ceci est une solution plus facile. Voir Stack Overflow question Vérification Wi-Fi activé ou non sur Android .

P.S. Ne pas oublier d'ajouter le code dans le fichier manifest.xml pour permettre 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>

Essayez 

wifiManager.getConnectionInfo().getIpAddress()

retourne 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 WIFI sur si elle n'a pas été activé comme suit  1. Vérifier l'état du WIFI en réponse par Chevalier @ Jason  2. Si non activé, activez ne pas oublier d'ajouter la permission WIFI dans le fichier manifeste 

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

Votre classe Java doit ê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();
}

}

Beaucoup de réponses utiliser le code désapprouvée, ou un code disponible sur les versions de l'API o supérieur. 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;

Le code suivant (en Kotlin) fonctionne à partir de l'API 21 jusqu'à au moins la version actuelle de l'API (API 29). La fonction getWifiState () retourne l'un des 3 valeurs possibles de l'état du réseau WiFi: Désactiver, EnabledNotConnected et Connected qui ont été définis dans une classe enum. Cela permet de prendre des décisions plus précises comme informer l'utilisateur d'activer le WiFi ou, si elle 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 Wi-Fi est connecté à un réseau, puis l'autre fonction isWifiConnected () vous donnera cela. Il utilise le précédent et compare le résultat à Connected.

Il est inspiré dans quelques-unes des réponses précédentes mais en essayant de résoudre les problèmes introduits par l'évolution des API Android ou la disponibilité de plus en plus lentement de la propriété intellectuelle V6. L'astuce consistait à utiliser: 

wifiManager.connectionInfo.bssid != null

au lieu de:

  1. getIpAddress () == 0 qui est valable uniquement pour V4 IP ou
  2. getNetworkId () == -1 qui exige maintenant une autre autorisation spéciale (emplacement)

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

ont également les points suivants à l'esprit:

  

Sur les versions antérieures android.os.Build.VERSION_CODES # N, cet objet   ne doit être obtenu à partir d'un contexte # getApplicationContext (), et   pas de tout autre contexte dérivés afin d'éviter les fuites de mémoire au sein de la   processus d'appel.

Dans le manifeste, ne pas oublier d'ajouter: 

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

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)
    }
}
Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top