Android'de Wi-Fi'nin bağlı olup olmadığını nasıl görebilirim?

Kullanıcının, Wi-Fi bağlı olmadıkça bir şey indirmeyi denemesini istemiyorum. Ancak, yalnızca Wi-Fi'nin etkin olup olmadığını söyleyebilirim, ancak yine de 3G bağlantısı olabilir.

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

Ancak devlet beklediğim gibi değil. Wi-Fi bağlı olmasına rağmen OBTAINING_IPADDR, devlet olarak alıyorum .

Wi-Fi bağdaştırıcısının durumunu almak için ConnectivityManager'ı kullanabilmeniz gerekir. Oradan bağlandığını veya hatta kullanılabilir olup olmadığını kontrol edebilirsiniz .

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

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

NOT: Eklemeniz gerektiğine dikkat edilmelidir (bizim için burada n00bies)

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

senin için

Bunun için AndroidManifest.xml .

NOT2 : public NetworkInfo getNetworkInfo (int networkType)artık kullanımdan kaldırıldı:

Bu yöntem, API düzey 23'te kullanımdan kaldırılmıştır. Bu yöntem, aynı türde birden çok bağlı ağı desteklemez. Bunun yerine getAllNetworks () ve getNetworkInfo (android.net.Network) kullanın.

NOT3 : public static final int TYPE_WIFIartık kullanımdan kaldırıldı:

Bu sabit, API 28 düzeyinde kullanımdan kaldırılmıştır. Uygulamalar bunun yerine uygun bir ağ istemek için NetworkCapabilities.hasTransport (int) veya requestNetwork (NetworkRequest, NetworkCallback) kullanmalıdır. Desteklenen nakliyeler için.

NetworkInfo.isConnected () yöntemi şimdi API-23'te kullanımdan kaldırıldığı için , Kablosuz bağdaştırıcının açık olup olmadığını ve bunun yerine WifiManager kullanarak bir erişim noktasına bağlanıp bağlanmadığını tespit eden bir yöntem aşağıdadır:

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

Sadece aşağıdakileri kullanıyorum:

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

Hangi getSupplicantState () çağırdığınızda bu durumlardan birini döndürür;

BAĞLI - Dernek tamamlandı.

DERNEĞİ - Bir erişim noktasıyla ilişkilendirilmeye çalışılıyor.

TAMAMLANDI - Tüm kimlik doğrulama tamamlandı.

BAĞLI DEĞİL - Bu durum, istemcinin ilişkili olmadığını, ancak bir erişim noktası aramaya başlayacağını gösterir.

DORMANT - İstemci açık bir DISCONNECT komutu verdiğinde bildirilen, Android tarafından eklenen bir durum.

FOUR_WAY_HANDSHAKE - WPA 4 Yollu Tuş Sıkışması devam ediyor.

GROUP_HANDSHAKE - WPA Grubu Anahtar El Sıkışma devam ediyor.

AKTİF DEĞİL - Aktif değil durumu.

GEÇERSİZ - Normalde asla görülmemesi gereken sahte bir durum.

TARAMA - Bir ağ taranıyor.

UNINITIALIZED - Bağlantı yok.

Etkin ağın Wi-Fi olup olmadığını kontrol etmek için uygulamalarımda kullanıyorum:

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

    // Do your work here

}

Bunun gibi birkaç soruya bir göz attım ve bununla geldim:

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
}

Root Toolbox PRO'daki lisans kontrolüm için eğer kullanıyorum ve harika çalışıyor gibi görünüyor.

İken Jason'ın cevabı doğrudur, günümüzde getNetWorkInfo (int) kaldırılmış bir yöntemdir. Yani, bir sonraki fonksiyon güzel bir alternatif olacaktır:

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

WifiManagerBunu kullanarak şunları yapabilirsiniz:

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

GetNeworkId yöntemi yalnızca bir ağa bağlı olmadığında -1 değerini döndürür;

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

Aşağıdaki kod (Kotlin'de) API 21'den en azından güncel API sürümüne (API 29) kadar çalışır. GetWifiState () işlevi, WiFi ağ durumu için 3 olası değerden birini döndürür: Enum sınıfında tanımlanan Disable, EnabledNotConnected ve Connected. Bu, kullanıcıyı WiFi'yi etkinleştirmesini veya zaten etkinleştirildiyse kullanılabilir ağlardan birine bağlanmasını bildirmek gibi daha ayrıntılı kararlar alınmasına olanak tanır. Ancak tüm gereken, WiFi arayüzünün bir ağa bağlı olup olmadığını gösteren bir boolean ise, diğer işlev isWifiConnected () size bunu verecektir. Bir öncekini kullanır ve sonucu Connected ile karşılaştırır.

Önceki yanıtlardan bazılarından ilham aldı, ancak Android API'lerinin evriminin veya IP V6'nın yavaş yavaş kullanılabilirliğinin getirdiği sorunları çözmeye çalışıyor. Hüner kullanmaktı:

wifiManager.connectionInfo.bssid != null 

onun yerine:

1. getIpAddress () == 0, yalnızca IP V4 veya
2. Şimdi başka bir özel izin gerektiren getNetworkId () == -1 (Konum)

Belgelere göre: https://developer.android.com/reference/kotlin/android/net/wifi/WifiInfo.html#getbssid bir ağa bağlı değilse null değerini döndürür. Ve gerçek değeri elde etme iznimiz olmasa bile, bağlandığımızda yine de null dışında bir şey döndürür.

Ayrıca aşağıdakileri aklınızda bulundurun:

Android.os.Build.VERSION_CODES # N öncesi sürümlerde, bu nesne çağıran süreçte bellek sızıntılarını önlemek için herhangi bir türetilmiş bağlamdan değil, yalnızca Context # getApplicationContext () öğesinden alınmalıdır.

Manifest'te eklemeyi unutmayın:

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

Önerilen kod:

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

NetworkInfoSınıf ilgili geçiş gibi yöntemler ile birlikte, API seviyesi 29 olarak kaldırıldı ConnectivityManager#getNetworkInfo()ve ConnectivityManager#getActiveNetworkInfo().

Dokümantasyon şimdi insanların kullanmayı önerirConnectivityManager.NetworkCallback asenkron geri arama izleme veya kullanım için API ConnectivityManager#getNetworkCapabilitiesveya ConnectivityManager#getLinkPropertiesağ bilgilerinin senkronize erişim için

Arayanlar bunun yerine bağlantı değişiklikleri hakkında bilgi edinmek için ConnectivityManager.NetworkCallback API'sini kullanmalı veya bilgileri eşzamanlı olarak almak için ConnectivityManager # getNetworkCapabilities veya ConnectivityManager # getLinkProperties kullanmaya başlamalıdır.

WiFi'nin bağlı olup olmadığını kontrol etmek için kullandığım kod:

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

ACCESS_NETWORK_STATEManifest dosyanıza da izin eklemeyi unutmayın .

Bu yöntemi deneyin.

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

Bu yöntem, kullanılabilir İnternet bağlantısını bulmanıza veya bulmamıza yardımcı olacaktır.

Bu benim için çalışıyor:

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

Ve bu izni ekleyin:

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

Yanıtların çoğu kullanımdan kaldırılmış kod veya daha yüksek API sürümlerinde bulunan kodu kullanır. Şimdi böyle bir şey kullanıyorum

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;

Uygulamalarımda bir yardımcı program olarak kullandığım şey:

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

Yeni Android sürümünde

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

    }
}

ve de prisyon ekleyin

@Jason Knight cevabına benzer, ancak Kotlin yolunda:

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

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

Bu daha kolay bir çözümdür. Bkz. Yığın Taşması sorusu Android'de Wi-Fi'nin etkin olup olmadığını kontrol etme .

Not İzin vermek için kodu manifest.xml dosyasına eklemeyi unutmayın. Aşağıda gösterildiği gibi.

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

Deneyin

wifiManager.getConnectionInfo().getIpAddress()

Cihazın kullanılabilir bir bağlantısı olana kadar bu 0 değerini döndürür (makinemde bir Samsung SM-T280, Android 5.1.1).

Aşağıdaki gibi etkinleştirilmemişse WIFI'yi açabilirsiniz 1. @Jason Knight tarafından cevaplandığı gibi WIFI durumunu kontrol edin 2. Etkinleştirilmemişse, etkinleştirin manifest dosyasına WIFI izni eklemeyi unutmayın

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

Java sınıfınız böyle olmalıdır

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

}

JAVA için ekleyin:

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

Manifest dosyasında aşağıdaki izinleri ekleyin:

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

Biraz eski bir soru ama kullandığım şey bu. min 21 api seviyesi gerektirir, aynı zamanda kullanımdan kaldırılmış Networkinfo apis dikkate alır.

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;