ConnectivityManager getNetworkInfo (int) kullanımdan kaldırıldı


144

Bununla birlikte, compileSdkVersion 23 kullanma 9'a kadar destek vermeye çalışıyor.

getNetworkInfo(int)23. kullanımdan kaldırıldı öneri kullanımına olduğu getAllNetworks()ve getNetworkInfo(Network)bunun yerine. Ancak bunların her ikisi de minimum API 21 gerektirir.

Destek paketinde bu konuda yardımcı olabilecek bir sınıf var mı?

Daha önce bir çözüm önerildiğini biliyorum , ancak 9 minimum API gereksinimimdeki zorluk bir sorun oluşturuyor.


derleme sürümünü çalışma zamanında kontrol edebilir ve uygun yöntemi kullanabilirsiniz
stinepike

1
Bu hala kullanımdan kaldırılmış bir uyarı gönderecek mi?
kyleED

Lütfen Android Nougat'ın altında ve üstünde API yöntemlerini içeren ConnectivityObserver sınıfımı kontrol edin .
JJD

Yanıtlar:


166

Kullanabilirsiniz:

getActiveNetworkInfo ();

ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
if (activeNetwork != null) { 
    // connected to the internet
    if (activeNetwork.getType() == ConnectivityManager.TYPE_WIFI) {
        // connected to wifi
    } else if (activeNetwork.getType() == ConnectivityManager.TYPE_MOBILE) {
        // connected to mobile data
    }
} else {
    // not connected to the internet
}

Veya bir anahtar kutusunda

ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
if (activeNetwork != null) { 
    // connected to the internet
    switch (activeNetwork.getType()) {
        case ConnectivityManager.TYPE_WIFI:
            // connected to wifi
            break;
        case ConnectivityManager.TYPE_MOBILE:
            // connected to mobile data
            break;
        default:
            break;
    }
} else {
    // not connected to the internet
}

1
@ShirishHerwade - Evet, bu durumda Yayın Alıcısı gerekli değildir. getActiveNetworkInfo (), bir bağlam referansı dahil edilmesi koşuluyla kendi yöntemine yerleştirilebilir.
Peynir Ekmeği

1
@TheIT - Evet doc, "Ağ trafiğini başlatmadan önce her zaman isConnected () öğesini kontrol etmelisiniz" diyor. Bu çözüm trafiği başlatmaz ve yalnızca kullanımdan kaldırılmış getNetworkInfo () çağrısına bir çözüm sağlar.
Peynir Ekmeği

7
Android 9'dan itibaren, SDK 28 artık kullanımdan kaldırıldı.
Zbarcea Christian

32
activeNetwork.getType()kullanımdan kaldırıldı ve ConnectivityManager.TYPE_WIFIkullanımdan kaldırıldı
Godwin

7
Değişim şimdicm.getNetworkCapabilities(cm.activeNetwork).hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)
tmm1

63

Ekim 2018'de kabul edilen cevap reddedildi.

getType()ve türlerin kendileri artık API Düzeyi 28'de kullanımdan kaldırılmıştır. Javadoc'tan:

Arayanlar bunun yerine NetworkCapability # TRANSPORT * sabitlerinden biriyle NetworkCapability # hasTransport'u denetlemeye geçmelidir

Kullanım için NetworkCapabilities, bir geçmeleri gerekiyor Networkiçin örnek getNetworkCapabilities()yöntemiyle. Bu örneği almak için aramanız gerekirgetActiveNetwork() API Seviye 23'e eklenen .

Bu yüzden şimdi Wi-Fi veya hücresel ağa bağlı olup olmadığınızı güvenle kontrol etmenin doğru yolunun olduğuna inanıyorum:

public static boolean isNetworkConnected() {
    final ConnectivityManager cm = (ConnectivityManager)context.getSystemService(Context.CONNECTIVITY_SERVICE);

    if (cm != null) {
        if (Build.VERSION.SDK_INT < 23) {
            final NetworkInfo ni = cm.getActiveNetworkInfo();

            if (ni != null) {
                return (ni.isConnected() && (ni.getType() == ConnectivityManager.TYPE_WIFI || ni.getType() == ConnectivityManager.TYPE_MOBILE));
            }
        } else {
            final Network n = cm.getActiveNetwork();

            if (n != null) {
                final NetworkCapabilities nc = cm.getNetworkCapabilities(n);

                return (nc.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) || nc.hasTransport(NetworkCapabilities.TRANSPORT_WIFI));
            }
        } 
    }

    return false; 
}

Ayrıca buradaTRANSPORT bulabileceğiniz diğer türleri de kontrol edebilirsiniz .

Önemli not: Wi-Fi'ye ve bir VPN'ye bağlıysanız , mevcut durumunuz olabilir TRANSPORT_VPN, bu yüzden de kontrol etmek isteyebilirsiniz.

AndroidManifest dosyanıza aşağıdaki izni eklemeyi unutmayın:

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

HasTransport (NetworkCapability.TRANSPORT_WIFI) ni.isConnected () && (ni.getType () == ConnnectivityManager.TYPE_WIFI) ile eşdeğer mi? Demek istediğim hasTransport () işlevi de cihazın bağlı mı yoksa bağlanmaya mı çalıştığını kontrol ediyor mu?
Bisküvi

Bir kez daha NetworkInfoamortismana tabi tutulur, artık kullanamazsınız NetWorkInfo, bu nasıl bir alternatif sağlar?
Prescott Chartier

@PrescottChartier bu kod pasajı yalnızca SDK <23 cihazda NetworkInfo'ya erişir
Tom

59

Şubat 2020 Güncellemesi:

Kabul edilen cevap tekrar kullanımdan kaldırıldı 28 (Android P), ancak değiştirme yöntemi yalnızca23 (Android M) . Daha eski cihazları desteklemek için içine bir yardımcı fonksiyon yazdım.

Nasıl kullanılır:

int type = getConnectionType(getApplicationContext());

Bir döndürür int, enumkodunuzda değiştirebilirsiniz:

0: İnternet yok (belki uçak modunda veya bir wi-fi'ye katılma sürecinde).

1: Hücresel (mobil veri, 3G / 4G / LTE).

2: Kablosuz.

3: VPN

Yardımcı işlevin Kotlin'i veya Java sürümünü kopyalayabilirsiniz.

Kotlin:

@IntRange(from = 0, to = 3)
fun getConnectionType(context: Context): Int {
    var result = 0 // Returns connection type. 0: none; 1: mobile data; 2: wifi
    val cm = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager?
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        cm?.run {
            cm.getNetworkCapabilities(cm.activeNetwork)?.run {
                if (hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
                    result = 2
                } else if (hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
                    result = 1
                } else if (hasTransport(NetworkCapabilities.TRANSPORT_VPN)){
                    result = 3
                }
            }
        }
    } else {
        cm?.run {
            cm.activeNetworkInfo?.run {
                if (type == ConnectivityManager.TYPE_WIFI) {
                    result = 2
                } else if (type == ConnectivityManager.TYPE_MOBILE) {
                    result = 1
                } else if(type == ConnectivityManager.TYPE_VPN) {
                    result = 3
                }
            }
        }
    }
    return result
}

Java:

@IntRange(from = 0, to = 3)
public static int getConnectionType(Context context) {
    int result = 0; // Returns connection type. 0: none; 1: mobile data; 2: wifi
    ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        if (cm != null) {
            NetworkCapabilities capabilities = cm.getNetworkCapabilities(cm.getActiveNetwork());
            if (capabilities != null) {
                if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
                    result = 2;
                } else if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
                    result = 1;
                } else if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_VPN)) {
                    result = 3;
                }
            }
        }
    } else {
        if (cm != null) {
            NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
            if (activeNetwork != null) {
                // connected to the internet
                if (activeNetwork.getType() == ConnectivityManager.TYPE_WIFI) {
                    result = 2;
                } else if (activeNetwork.getType() == ConnectivityManager.TYPE_MOBILE) {
                    result = 1;
                } else if (activeNetwork.getType() == ConnectivityManager.TYPE_VPN) {
                    result = 3;
                }
            }
        }
    }
    return result;
}

2
2 sonuç elde edebileceğiniz gibi, bir tamsayı döndürmek yerine bir boolean kullanmak daha iyidir ...
Christian

3
@Christian olarak, bu yardımcı fonksiyon 3 olası durumları döndürür, san bir bölümde açıklanmıştır: No Internet, Cellularve Wi-Fi. Bağlantı türünü önemsemiyorsanız, kodu uygulamanıza uyacak şekilde değiştirmekten çekinmeyin.
user1032613

1
yukarıdaki çözümdeki yorum "ya Wi-Fi ve bir VPN'ye bağlıysanız, mevcut durumunuz TRANSPORT_VPN olabilir, bu yüzden de kontrol etmek isteyebilirsiniz."?
David

1
@Lukas , ilkel Booleanyerine sarıcı sınıfı kullanırsanız dikkatli olmalısınız boolean. İf ifadesinde çek eklemeniz gerekecek null. Ayrıca yarın NetworkCapability'de başka bir yeni Aktarım modu piyasaya sürülürse ... dallanma için tamsayı kullanmak yardımcı olur ve ayrıca anahtar durumları için gidebilirsiniz.
Gölge Droid

3
bu sürekli kullanımdan
kaldırma

16

Güncel cevap (19: 07: 2018):

Bu yöntem, internet bağlantısının mevcut olup olmadığını kontrol etmenize yardımcı olacaktır.

public static boolean isNetworkAvailable(Context context) {
    ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);

    if (connectivityManager != null) {
        NetworkInfo activeNetwork = connectivityManager.getActiveNetworkInfo();
        return (activeNetwork != null && activeNetwork.isConnectedOrConnecting());
    } else {
        return false;
    }
}

Eski cevap:

En iyi kod yeniden kullanımı için, peynir ekmeği doğaçlama cevap.

public static boolean isNetworkAvailable(Context context) {
    int[] networkTypes = {ConnectivityManager.TYPE_MOBILE,
            ConnectivityManager.TYPE_WIFI};
    try {
        ConnectivityManager connectivityManager =
                (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        for (int networkType : networkTypes) {
            NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
            if (activeNetworkInfo != null &&
                    activeNetworkInfo.getType() == networkType)
                return true;
        }
    } catch (Exception e) {
        return false;
    }
    return false;
}

Kod, Util sınıfına yerleştirilebilir ve telefonunuzun, uygulamanızın herhangi bir bölümünden Wifi veya Mobil İnternet yoluyla İnternet'e bağlı olup olmadığını kontrol etmek için kullanılabilir.


3
Aktif ağın for döngüsünün dışına taşınmasını öneririm.
shtolik

20
activeNetwork.isConnectedOrConnecting()şimdi kullanımdan kaldırıldı
MHSFisher

1
ActiveNetwork.isConnectedOrConnecting () öğesini activeNetwork.isConnected olarak değiştiririm
Murillo Comino

NetworkInfo artık kullanılmıyor. Tekrar güncellemeniz gerekiyor!
Scott Biggs

13

Kabul edilen cevap 28. sürümde kullanımdan kaldırılmıştır, bu yüzden projemde kullandığım çözüm.

Bağlantı türünü döndürür. false: İnternet Bağlantısı yok; true: mobil veri || kablosuz internet

public static boolean isNetworkConnected(Context context) { 
    boolean result = false; 
    ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        if (cm != null) {
            NetworkCapabilities capabilities = cm.getNetworkCapabilities(cm.getActiveNetwork());
            if (capabilities != null) {
                if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
                    result = true;
                } else if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
                    result = true;
                }
            }
        }
    } else {
        if (cm != null) {
            NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
            if (activeNetwork != null) {
                // connected to the internet
                if (activeNetwork.getType() == ConnectivityManager.TYPE_WIFI) {
                    result = true;
                } else if (activeNetwork.getType() == ConnectivityManager.TYPE_MOBILE) {
                    result = true;
                }
            }
        }
    }
    return result;
}

2
activeNetwork.getType () da kullanımdan kaldırıldı. ActiveNetwork.isConnected ();
Aman Verma

11

Bu cevaba Mart 2020'den itibaren API.15 - API.29'u destekleyen bir güncelleme var, cevabı orijinal cevabın ardından bulabilirsiniz

Cevap Şubat 2019

Çevrimiçi olup olmadığınızı kontrol etmek için:

boolean isOnline() {
    // Checking internet connectivity
    ConnectivityManager connectivityMgr = (ConnectivityManager) this.getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo activeNetwork = null;
    if (connectivityMgr != null) {
        activeNetwork = connectivityMgr.getActiveNetworkInfo();
    }
    return activeNetwork != null;
}

Android M'den önce / sonra internet bağlantısı türünü almak için

void internetType() {
    // Checking internet connectivity
    ConnectivityManager connectivityMgr = (ConnectivityManager) this.getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo activeNetwork = null;
    if (connectivityMgr != null) {
        activeNetwork = connectivityMgr.getActiveNetworkInfo();
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            NetworkCapabilities nc = connectivityMgr.getNetworkCapabilities(connectivityMgr.getActiveNetwork());
            if (nc.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
                // connected to mobile data
            } else if (nc.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
                // connected to wifi
            }
        } else {
            if (activeNetwork.getType() == ConnectivityManager.TYPE_WIFI) {
                // connected to wifi
            } else if (activeNetwork.getType() == ConnectivityManager.TYPE_MOBILE) {
                // connected to mobile data
            }
        }
    }
}

Tüm durumlar ağ durumuna erişmek için izin gerektirir

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

Mart 2020 Güncellemesi

Kullanımdan NetworkInfokaldırıldığı gibi ve API 29'dan itibaren ConnectivityManager.NetworkCallbackağ durumu değişikliği onAvailable()ve onLost()geri aramalarıyla birlikte kullanmak zorundayız .

Kullanımı:

  • Ya kullanabilirsiniz Bu kütüphaneyi ya da doğrudan bu kütüphanenin bir parçası olan yarar sınıfının altındaki kullanın.

Özellikleri

  • Yöntemde LifecycleObserverbiraz temizleme yaparak bellek sızıntısını önlemek için uygulayarak LifeCycle bilincindedir onDestroy().
  • API 15 (Ice Cream Sandwich) ile API 29 (Android Q) arasında desteklenir
  • API 21'den önceki API'lar için, içeriğe dayalı BoradcastReceiverve API 21 ve üstü için NetworkInfokullanır ConnectivityManager.NetworkCallback.
  • Hem WiFi hem de hücresel ağlar açık olduğunda, hücresel ağa geçerken WiFi bağlantısı kesildiğinde bağlantı dinleyicisi kesilmez.
  • Hücresel ağ açık olduğunda, WiFi bağlandığında ve etkin ağ olduğunda bağlantı dinleyicisi kesilmez (bu tercih edilen ağdır).
  • Kütüphaneyi kullanacaksanız, bu izni eklemenize gerek yoktur android.permission.ACCESS_NETWORK_STATE; ancak yardımcı program sınıfını kullanacaksanız eklemeniz gerekir.

Yetenekleri

  • Geçerli bağlantı durumunu alma (çevrimiçi / çevrimdışı).
  • İnternet bağlantısını sürekli kontrol etme / dinleme ve cihaz çevrimdışı veya çevrimiçi olduğunda geri aramayı tetikleme.
  • Etkin internet bağlantısı türünü (WiFi veya Hücresel) alın.
  • Mevcut tüm ağların türünü (WiFi veya Hücresel) alın. >> Yalnızca API 21 ve üstü sürümlerde desteklenir
  • Mevcut tüm ağların sayısını alın >> Yalnızca API 21+ üzerinde desteklenir
@RequiresApi(api = Build.VERSION_CODES.ICE_CREAM_SANDWICH_MR1)
public class ConnectionUtil implements LifecycleObserver {

    private static final String TAG = "LOG_TAG";
    private ConnectivityManager mConnectivityMgr;
    private Context mContext;
    private NetworkStateReceiver mNetworkStateReceiver;

    /*
     * boolean indicates if my device is connected to the internet or not
     * */
    private boolean mIsConnected = false;
    private ConnectionMonitor mConnectionMonitor;


    /**
     * Indicates there is no available network.
     */
    private static final int NO_NETWORK_AVAILABLE = -1;


    /**
     * Indicates this network uses a Cellular transport.
     */
    public static final int TRANSPORT_CELLULAR = 0;


    /**
     * Indicates this network uses a Wi-Fi transport.
     */
    public static final int TRANSPORT_WIFI = 1;


    public interface ConnectionStateListener {
        void onAvailable(boolean isAvailable);
    }


    public ConnectionUtil(Context context) {
        mContext = context;
        mConnectivityMgr = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        ((AppCompatActivity) mContext).getLifecycle().addObserver(this);

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            mConnectionMonitor = new ConnectionMonitor();
            NetworkRequest networkRequest = new NetworkRequest.Builder()
                    .addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR)
                    .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
                    .build();
            mConnectivityMgr.registerNetworkCallback(networkRequest, mConnectionMonitor);
        }

    }


    /**
     * Returns true if connected to the internet, and false otherwise
     *
     * <p>
     * NetworkInfo is deprecated in API 29
     * https://developer.android.com/reference/android/net/NetworkInfo
     * <p>
     * getActiveNetworkInfo() is deprecated in API 29
     * https://developer.android.com/reference/android/net/ConnectivityManager#getActiveNetworkInfo()
     * <p>
     * getNetworkInfo(int) is deprecated as of API 23
     * https://developer.android.com/reference/android/net/ConnectivityManager#getNetworkInfo(int)
     */
    public boolean isOnline() {

        mIsConnected = false;

        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.P) {
            // Checking internet connectivity
            NetworkInfo activeNetwork = null;
            if (mConnectivityMgr != null) {
                activeNetwork = mConnectivityMgr.getActiveNetworkInfo(); // Deprecated in API 29
            }
            mIsConnected = activeNetwork != null;

        } else {
            Network[] allNetworks = mConnectivityMgr.getAllNetworks(); // added in API 21 (Lollipop)

            for (Network network : allNetworks) {
                NetworkCapabilities networkCapabilities = mConnectivityMgr.getNetworkCapabilities(network);
                if (networkCapabilities != null) {
                    if (networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
                            || networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)
                            || networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET))
                        mIsConnected = true;
                }
            }
        }

        return mIsConnected;

    }


    /**
     * Returns
     * <p> <p>
     * <p><p> NO_NETWORK_AVAILABLE >>> when you're offline
     * <p><p> TRANSPORT_CELLULAR >> When Cellular is the active network
     * <p><p> TRANSPORT_WIFI >> When Wi-Fi is the Active network
     * <p>
     */
    public int getActiveNetwork() {

        NetworkInfo activeNetwork = mConnectivityMgr.getActiveNetworkInfo(); // Deprecated in API 29
        if (activeNetwork != null)

            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                NetworkCapabilities capabilities = mConnectivityMgr.getNetworkCapabilities(mConnectivityMgr.getActiveNetwork());
                if (capabilities != null)
                    if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
                        // connected to mobile data
                        return TRANSPORT_CELLULAR;

                    } else if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
                        // connected to wifi
                        return TRANSPORT_WIFI;
                    }

            } else {
                if (activeNetwork.getType() == ConnectivityManager.TYPE_MOBILE) { // Deprecated in API 28
                    // connected to mobile data
                    return TRANSPORT_CELLULAR;

                } else if (activeNetwork.getType() == ConnectivityManager.TYPE_WIFI) { // Deprecated in API 28
                    // connected to wifi
                    return TRANSPORT_WIFI;
                }
            }
        return NO_NETWORK_AVAILABLE;
    }


    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    public int getAvailableNetworksCount() {

        int count = 0;

        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP) {
            Network[] allNetworks = mConnectivityMgr.getAllNetworks(); // added in API 21 (Lollipop)
            for (Network network : allNetworks) {
                NetworkCapabilities networkCapabilities = mConnectivityMgr.getNetworkCapabilities(network);
                if (networkCapabilities != null)
                    if (networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
                            || networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR))
                        count++;
            }

        }

        return count;
    }


    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    public List<Integer> getAvailableNetworks() {

        List<Integer> activeNetworks = new ArrayList<>();

        Network[] allNetworks; // added in API 21 (Lollipop)
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP) {
            allNetworks = mConnectivityMgr.getAllNetworks();
            for (Network network : allNetworks) {
                NetworkCapabilities networkCapabilities = mConnectivityMgr.getNetworkCapabilities(network);
                if (networkCapabilities != null) {
                    if (networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI))
                        activeNetworks.add(TRANSPORT_WIFI);

                    if (networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR))
                        activeNetworks.add(TRANSPORT_CELLULAR);

                }
            }
        }

        return activeNetworks;
    }


    public void onInternetStateListener(ConnectionStateListener listener) {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
            mNetworkStateReceiver = new NetworkStateReceiver(listener);
            IntentFilter intentFilter = new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION);
            mContext.registerReceiver(mNetworkStateReceiver, intentFilter);

        } else {
            mConnectionMonitor.setOnConnectionStateListener(listener);
        }
    }


    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void onDestroy() {
        Log.d(TAG, "onDestroy");
        ((AppCompatActivity) mContext).getLifecycle().removeObserver(this);

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            if (mConnectionMonitor != null)
                mConnectivityMgr.unregisterNetworkCallback(mConnectionMonitor);
        } else {
            if (mNetworkStateReceiver != null)
                mContext.unregisterReceiver(mNetworkStateReceiver);
        }

    }


    public class NetworkStateReceiver extends BroadcastReceiver {

        ConnectionStateListener mListener;

        public NetworkStateReceiver(ConnectionStateListener listener) {
            mListener = listener;
        }

        @Override
        public void onReceive(Context context, Intent intent) {
            if (intent.getExtras() != null) {

                NetworkInfo activeNetworkInfo = mConnectivityMgr.getActiveNetworkInfo(); // deprecated in API 29

                /*
                 * activeNetworkInfo.getState() deprecated in API 28
                 * NetworkInfo.State.CONNECTED deprecated in API 29
                 * */
                if (!mIsConnected && activeNetworkInfo != null && activeNetworkInfo.getState() == NetworkInfo.State.CONNECTED) {
                    Log.d(TAG, "onReceive: " + "Connected To: " + activeNetworkInfo.getTypeName());
                    mIsConnected = true;
                    mListener.onAvailable(true);

                } else if (intent.getBooleanExtra(ConnectivityManager.EXTRA_NO_CONNECTIVITY, Boolean.FALSE)) {
                    if (!isOnline()) {
                        mListener.onAvailable(false);
                        mIsConnected = false;
                    }

                }

            }
        }
    }


    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    public class ConnectionMonitor extends ConnectivityManager.NetworkCallback {

        private ConnectionStateListener mConnectionStateListener;

        void setOnConnectionStateListener(ConnectionStateListener connectionStateListener) {
            mConnectionStateListener = connectionStateListener;
        }

        @Override
        public void onAvailable(@NonNull Network network) {

            if (mIsConnected)
                return;

            Log.d(TAG, "onAvailable: ");

            if (mConnectionStateListener != null) {
                mConnectionStateListener.onAvailable(true);
                mIsConnected = true;
            }

        }

        @Override
        public void onLost(@NonNull Network network) {

            if (getAvailableNetworksCount() == 0) {
                mConnectionStateListener.onAvailable(false);
                mIsConnected = false;
            }

        }

    }

}

@Rasel lütfen güncellenmiş cevabı kontrol edin, umarım yardımcı olabilir
Zain

Kullanıcı Wifi ve mobil verilere aynı anda bağlıysa ve bunlardan birinde bağlantı kaybedilirse onLostaranır. onLostcihazın internet bağlantısını kaybettiği anlamına gelmez, ancak bir Ağ bağlantıyı kaybetti.
Gökhan Arık

@Gokhan Arik .. Güzel yakalama çözme üzerinde çalışıyorum
Zain


@GokhanArik yardım için teşekkürler .. Cevabımı güncelledim ve genişletilmiş API kullanımı, herhangi bir hata fark ederseniz lütfen bana bildirin
Zain

4

Ağınızın İnternet'e bağlı olup olmadığını kontrol etmek iyidir:

@Suppress("DEPRECATION")
fun isNetworkAvailable(context: Context): Boolean {
    try {
        val cm = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
        return if (Build.VERSION.SDK_INT > 22) {
            val an = cm.activeNetwork ?: return false
            val capabilities = cm.getNetworkCapabilities(an) ?: return false
            capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
        } else {
            val a = cm.activeNetworkInfo ?: return false
            a.isConnected && (a.type == ConnectivityManager.TYPE_WIFI || a.type == ConnectivityManager.TYPE_MOBILE)
        }
    } catch (e: Exception) {
        e.printStackTrace()
    }
    return false
}

Ayrıca kontrol etmek isteyebilirsiniz NetworkCapabilities.NET_CAPABILITY_VALIDATED.
JJD

3

Kotlin versiyonu:

fun isInternetOn(context: Context): Boolean {
   val cm = context.getSystemService(Context.CONNECTIVITY_SERVICE) as? ConnectivityManager
   val activeNetwork = cm?.activeNetworkInfo
   return activeNetwork != null && activeNetwork.isConnected
}

3

As Peynir Ekmek önerdi kullanmak ) (getActiveNetworkInfo

getActiveNetworkInfo

API seviye 1'de eklendi

NetworkInfo getActiveNetworkInfo ()

O anda etkin olan varsayılan veri ağı hakkındaki ayrıntıları döndürür. Bağlandığında, bu ağ giden bağlantılar için varsayılan yoldur. Ağ trafiğini başlatmadan önce her zaman isConnected () öğesini kontrol etmelisiniz. Varsayılan ağ olmadığında bu null değerini döndürebilir. Bu yöntem, arayan kişinin ACCESS_NETWORK_STATE iznine sahip olmasını gerektirir. Geçerli varsayılan ağ için NetworkInfo öğesini bir NetworkInfo nesnesi veya etkin durumda etkin bir ağ yoksa null değeri döndürür.

Referans: Android Studio

 public final boolean isInternetOn() {

    // get Connectivity Manager object to check connection
    ConnectivityManager connec =
            (ConnectivityManager)getSystemService(getBaseContext().CONNECTIVITY_SERVICE);

    // Check for network connections
    if ( connec.getActiveNetworkInfo().getState() == android.net.NetworkInfo.State.CONNECTED ||
            connec.getActiveNetworkInfo().getState() == android.net.NetworkInfo.State.CONNECTING ) {

        // if connected with internet

        Toast.makeText(this, connec.getActiveNetworkInfo().getTypeName(), Toast.LENGTH_LONG).show();
        return true;

    } else if (
            connec.getActiveNetworkInfo().getState() == android.net.NetworkInfo.State.DISCONNECTED ||
                    connec.getActiveNetworkInfo().getState() == android.net.NetworkInfo.State.DISCONNECTED  ) {

        Toast.makeText(this, " Not Connected ", Toast.LENGTH_LONG).show();
        return false;
    }
    return false;
}

şimdi yöntemi arayın, güvenli kullanım için yakalamayı deneyin

try {
    if (isInternetOn()) { /* connected actions */ }
    else { /* not connected actions */ }
} catch (Exception e){
  Toast.makeText(this, e.getMessage(), Toast.LENGTH_SHORT).show();
}

Ve eklemeyi unutmayın:

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

teşekkür ederim faydalıdır. ne zaman biz ağ durumunu kontrol ve wifi ve veri her ikisi de kapalı-o zaman app çökmesine ama yakalamak deneyin sorunu çözmek ..
Rucha Bhatt Joshi

Ancak belirli bir ağ türünün mevcut olup olmadığını kontrol etmek istersem bu çalışmaz, tüm ağları numaralandırır, yanigetNetworkInfo(ConnectivityManager.TYPE_ETHERNET).isAvailable
m0skit0

3
getState () kullanımdan kaldırıldı!
Diego Venâncio

Onaylanmamış birkaç talimat!
Scott Biggs

2

Güvenli tarafta olmak için, aynı zamanda yöntemi kullanmanızı öneririm

NetworkInfo.isConnected ()

Tüm yöntem aşağıdaki gibi olabilir:

/**
 * Checking whether network is connected
 * @param context Context to get {@link ConnectivityManager}
 * @return true if Network is connected, else false
 */
public static boolean isConnected(Context context){
    ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
    if (activeNetwork != null && activeNetwork.isConnected()) {
        int networkType = activeNetwork.getType();
        return networkType == ConnectivityManager.TYPE_WIFI || networkType == ConnectivityManager.TYPE_MOBILE;
    } else {
        return false;
    }
}

9
activeNetwork.getType()kullanımdan kaldırıldı ve ConnectivityManager.TYPE_WIFI kullanımdan kaldırıldı
Godwin

2

Mevcut ağın en son Android sürümlerinde hücresel olup olmadığını nasıl kontrol edeceğim:

val isCellular: Boolean get() {
    val cm = getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        cm.getNetworkCapabilities(cm.activeNetwork).hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)
    } else {
        cm.activeNetworkInfo?.type == ConnectivityManager.TYPE_MOBILE
    }
}

2

(Neredeyse) Tüm cevaplar Android P'de kullanımdan kaldırıldı, bu yüzden C#çözüm ( Java geliştiricileri için takip edilmesi kolay )

public bool IsOnline(Context context)
{
    var cm = (ConnectivityManager)context.GetSystemService(Context.ConnectivityService);

    if (cm == null) return false;

    if (Build.VERSION.SdkInt < BuildVersionCodes.M)
    {
        var ni = cm.ActiveNetworkInfo;

        if (ni == null) return false;

        return ni.IsConnected && (ni.Type == ConnectivityType.Wifi || ni.Type == ConnectivityType.Mobile);
    }

    return cm.GetNetworkCapabilities(cm.ActiveNetwork).HasTransport(Android.Net.TransportType.Wifi)
        || cm.GetNetworkCapabilities(cm.ActiveNetwork).HasTransport(Android.Net.TransportType.Cellular);
}   

Buradaki anahtar Android.Net.TransportType


Aaaannnndddd bu konuda her şey DEPRECIATED!
Prescott Chartier

Hangi sürümde @PrescottChartier?
Mehdi Dehghani

2

İnternet bağlantısını bir kereden fazla kontrol etmemiz gerekebilir. Kod bloğunu bir uzantı yönteminde yazarsak, bizim için daha kolay olacaktır Context. Aşağıda Contextve için yardımcı uzantılarım var Fragment.

İnternet Bağlantısını Kontrol Etme

fun Context.hasInternet(): Boolean {
    val connectivityManager = getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    return if (Build.VERSION.SDK_INT < 23) {
        val activeNetworkInfo = connectivityManager.activeNetworkInfo
        activeNetworkInfo != null && activeNetworkInfo.isConnected
    } else {
        val nc = connectivityManager.getNetworkCapabilities(connectivityManager.activeNetwork)
        if (nc == null) {
            false
        } else {
            nc.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) ||
                    nc.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
        }
    }
}

Diğer Uzantılar

fun Context.hasInternet(notifyNoInternet: Boolean = true, trueFunc: (internet: Boolean) -> Unit) {
    if (hasInternet()) {
        trueFunc(true)
    } else if (notifyNoInternet) {
        Toast.makeText(this, "No Internet Connection!", Toast.LENGTH_SHORT).show()
    }
}

fun Context.hasInternet(
    trueFunc: (internet: Boolean) -> Unit,
    falseFunc: (internet: Boolean) -> Unit
) {
    if (hasInternet()) {
        trueFunc(true)
    } else {
        falseFunc(true)
    }
}

fun Fragment.hasInternet(): Boolean = context!!.hasInternet()

fun Fragment.hasInternet(notifyNoInternet: Boolean = true, trueFunc: (internet: Boolean) -> Unit) =
    context!!.hasInternet(notifyNoInternet, trueFunc)

fun Fragment.hasInternet(
    trueFunc: (internet: Boolean) -> Unit, falseFunc: (internet: Boolean) -> Unit
) = context!!.hasInternet(trueFunc, falseFunc)

2

İnternetin mevcut olup olmadığını kontrol et

@RequiresPermission(allOf = [
    Manifest.permission.ACCESS_NETWORK_STATE, 
    Manifest.permission.INTERNET
])
fun isInternetAvailable(context: Context): Boolean {
    val connectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager?
    val activeNetworkInfo = connectivityManager!!.activeNetworkInfo
    return activeNetworkInfo != null && activeNetworkInfo.isConnected
}

2

connectivityManager.getActiveNetwork () android M (API 28) altında bulunamadı. networkInfo.getState () android L'nin üzerinde kullanımdan kaldırılmıştır.

Yani, nihai cevap:

public static boolean isConnectingToInternet(Context mContext) {
    if (mContext == null) return false;

    ConnectivityManager connectivityManager = (ConnectivityManager) mContext.getSystemService(Context.CONNECTIVITY_SERVICE);
    if (connectivityManager != null) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            final Network network = connectivityManager.getActiveNetwork();
            if (network != null) {
                final NetworkCapabilities nc = connectivityManager.getNetworkCapabilities(network);

                return (nc.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) ||
                        nc.hasTransport(NetworkCapabilities.TRANSPORT_WIFI));
            }
        } else {
            NetworkInfo[] networkInfos = connectivityManager.getAllNetworkInfo();
            for (NetworkInfo tempNetworkInfo : networkInfos) {
                if (tempNetworkInfo.isConnected()) {
                    return true;
                }
            }
        }
    }
    return false;
}

1
Diyelim ki getActiveNetwork () Android altında M altında bulunamadı, ancak kodunuz Lollipop!
3c71

2

Birçok cevap hala kullanımdan kaldırılan 23'ün altında getNetworkType kullanıyor ; Cihazın internet bağlantısı olup olmadığını kontrol etmek için aşağıdaki kodu kullanın.

public static boolean isNetworkConnected(Context context) {

    ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);

    if (cm != null) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            NetworkCapabilities capabilities = cm.getNetworkCapabilities(cm.getActiveNetwork());
            return capabilities != null && (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) || capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR));
        } else {
            NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
            return activeNetwork != null && activeNetwork.isConnected();
        }
    }

    return false;
}

..

Ve bu satırı Manifest'e eklemeyi unutmayın

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

1

Gönderilen yanıtlar yalnızca etkin ağı sorgulamanıza izin verdiğinden NetworkInfo, yalnızca etkin olanı değil (örneğin Wifi ağı) herhangi bir ağ için nasıl elde edeceğiniz aşağıda açıklanmıştır (üzgünüm, Kotlin kodu önde)

(getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager).run {
    allNetworks.find { getNetworkInfo(it).type == ConnectivityManager.TYPE_WIFI }?.let { network -> getNetworkInfo(network) }
//    getNetworkInfo(ConnectivityManager.TYPE_WIFI).isAvailable // This is the deprecated API pre-21
}

Bunun için API 21 veya üstü ve izin gerekir android.permission.ACCESS_NETWORK_STATE


1
currentNetwork.getType () ve ConnectivityManager.TYPE_WIFI, API 28'de kullanımdan kaldırılmıştır.
Abushawish

@Abushawish API 28 için önerilen çözüm nedir?
tmm1

Değişim şimdicm.getNetworkCapabilities(cm.activeNetwork).hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)
tmm1

1

Android'de İnternet bağlantısını kontrol etmek için kullanabileceğiniz NetManagerKotlin

Eğer kullanırsanız minSdkVersion'ın> = 23

class NetManager @Inject constructor(var applicationContext: Context) {
    val isConnectedToInternet: Boolean?
        get() = with(
            applicationContext.getSystemService(Context.CONNECTIVITY_SERVICE)
                    as ConnectivityManager
        ) {
            isConnectedToInternet()
        }
}

fun ConnectivityManager.isConnectedToInternet() = isConnected(getNetworkCapabilities(activeNetwork))

fun isConnected(networkCapabilities: NetworkCapabilities?): Boolean {
    return when (networkCapabilities) {
        null -> false
        else -> with(networkCapabilities) { hasTransport(TRANSPORT_CELLULAR) || hasTransport(TRANSPORT_WIFI) }
    }
}

Eğer kullanırsanız <23 minSdkVersion'ın

class NetManager @Inject constructor(var applicationContext: Context) {
    val isConnectedToInternet: Boolean?
        get() = with(
            applicationContext.getSystemService(Context.CONNECTIVITY_SERVICE)
                    as ConnectivityManager
        ) {
            isConnectedToInternet()
        }
}

fun ConnectivityManager.isConnectedToInternet(): Boolean = if (Build.VERSION.SDK_INT < 23) {
    isConnected(activeNetworkInfo)
} else {
    isConnected(getNetworkCapabilities(activeNetwork))
}


fun isConnected(network: NetworkInfo?): Boolean {
    return when (network) {
        null -> false
        else -> with(network) { isConnected && (type == TYPE_WIFI || type == TYPE_MOBILE) }
    }
}

fun isConnected(networkCapabilities: NetworkCapabilities?): Boolean {
    return when (networkCapabilities) {
        null -> false
        else -> with(networkCapabilities) { hasTransport(TRANSPORT_CELLULAR) || hasTransport(TRANSPORT_WIFI) }
    }
}

1

https://www.agnosticdev.com/content/how-detect-network-connectivity-android

lütfen cevap arayan herkese yardımcı olması gereken bu öğreticiyi izleyin.

not networkInfo kullanımdan kaldırılmıştır, dolayısıyla parametre olarak getApplicationContext () 'i geçmenin altında @vidha yanıtı ile isNetworkReacheable ()

  public static boolean isNetworkReacheable(Context context) {
    boolean result = false;
    ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        if (cm != null) {
            NetworkCapabilities capabilities = cm.getNetworkCapabilities(cm.getActiveNetwork());
            if (capabilities != null) {
                if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
                    result = true;
                } else if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
                    result = true;
                }
            }
        }
    } else {
        if (cm != null) {
            NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
            if (activeNetwork != null) {
                // connected to the internet
                if (activeNetwork.getType() == ConnectivityManager.TYPE_WIFI) {
                    result = true;
                } else if (activeNetwork.getType() == ConnectivityManager.TYPE_MOBILE) {
                    result = true;
                }
            }
        }
    }
    return result;
}

0
public boolean isConnectedToWifi(Context context) {
    ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    if (connectivityManager == null) {
        return false;
    }

    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
        Network network = connectivityManager.getActiveNetwork();
        NetworkCapabilities capabilities = connectivityManager.getNetworkCapabilities(network);
        if (capabilities == null) {
            return false;
        }
        return capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI);
    } else {
        NetworkInfo networkInfo = connectivityManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
        if (networkInfo == null) {
            return false;
        }
        return networkInfo.isConnected();
    }
}

0

Bu Kotlin'de benim için çalışıyor. Birçok API, Network Manager sınıfında kullanımdan kaldırılmıştır, bu nedenle aşağıdaki yanıt tüm API desteğini kapsamaktadır.

fun isNetworkAvailable(context: Context): Boolean {
    var result = false
    (context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager).apply {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                result = isCapableNetwork(this,this.activeNetwork)
            } else {
                val networkInfos = this.allNetworks
                for (tempNetworkInfo in networkInfos) {
                    if(isCapableNetwork(this,tempNetworkInfo))
                        result =  true
                }
            }
        }

    return result
}

fun isCapableNetwork(cm: ConnectivityManager,network: Network?): Boolean{
     cm.getNetworkCapabilities(network)?.also {
        if (it.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
            return true
        } else if (it.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
            return true
        }
    }
    return false
}

Aşağıya da ekleyeceksiniz

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

0

Aşağıdaki kod tüm API'larda çalışır. (Kotlin)

Bununla birlikte, getActiveNetworkInfo () yalnızca API 29'da kullanımdan kaldırılmıştır ve tüm API'larda çalışır, bu nedenle onu aşağıdaki Api'nin altındaki tüm Api'lerde kullanabiliriz 29

fun isInternetAvailable(context: Context): Boolean {
            var result = false
            val connectivityManager =
                context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                val networkCapabilities = connectivityManager.activeNetwork ?: return false
                val actNw =
                    connectivityManager.getNetworkCapabilities(networkCapabilities) ?: return false
                result = when {
                    actNw.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) -> true
                    actNw.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) -> true
                    actNw.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET) -> true
                    else -> false
                }
            } else {
                connectivityManager.run {
                    connectivityManager.activeNetworkInfo?.run {
                        result = when (type) {
                            ConnectivityManager.TYPE_WIFI -> true
                            ConnectivityManager.TYPE_MOBILE -> true
                            ConnectivityManager.TYPE_ETHERNET -> true
                            else -> false
                        }

                    }
                }
            }

            return result
        }

0

Bunun gibi bir şey:

public boolean hasConnection(final Context context){
    ConnectivityManager cm = (ConnectivityManager)context.getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo activeNW = cm.getActiveNetworkInfo();
    if (activeNW != null && activeNW.isConnected())
    {
        return true;
    }
    return false;
}

Ve ana program gövdesinde:

if(hasConnection(this)) {
    Toast.makeText(this, "Active networks OK ", Toast.LENGTH_LONG).show();
    getAccountData(token, tel);
}
else  Toast.makeText(this, "No active networks... ", Toast.LENGTH_LONG).show();

0

Bu, Android 10'da da çalışacaktır. İnternete bağlıysa yanlış dönerse true değerini döndürür.

private fun isOnline(): Boolean {
        val connectivityManager =
                getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
        val capabilities =
                connectivityManager.getNetworkCapabilities(connectivityManager.activeNetwork)
        if (capabilities != null) {
            when {
                capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) -> {
                    Log.i("Internet", "NetworkCapabilities.TRANSPORT_CELLULAR")
                    return true
                }
                capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) -> {
                    Log.i("Internet", "NetworkCapabilities.TRANSPORT_WIFI")
                    return true
                }
                capabilities.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET) -> {
                    Log.i("Internet", "NetworkCapabilities.TRANSPORT_ETHERNET")
                    return true
                }
            }
        }
        return false
    }
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.