it-roy-ru.com

ConnectivityManager getNetworkInfo (int) устарела

Используя compileSdkVersion 23, однако пытался поддерживать еще в 9.

getNetworkInfo (int) устарела в версии 23. Вместо этого было предложено использовать getAllNetworks и getNetworkInfo (Network). Однако оба из них требуют минимум API 21.

Есть ли класс, который мы можем использовать в пакете поддержки, который может помочь с этим?

Я знаю, что решение было предложено до , однако проблема, связанная с моими минимальными требованиями к API, равными 9, ставит проблему.

75
kyleED

Ты можешь использовать:

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
        }

Или в случае выключателя

        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
        }
137
Cheese Bread

Обновленный ответ (19: 07: 2018):

Этот метод поможет вам проверить доступность интернет-соединения.

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

Старый ответ:

Для лучшей практики повторного использования кода, импровизирующий ответ на сырный хлеб.

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

Код может быть помещен в класс Util и может использоваться для проверки, подключен ли телефон к Интернету через Wi-Fi или мобильный Интернет из любой части вашего приложения.

14
Nishanth Sreedhara

По состоянию на октябрь 2018 года принятый ответ устарел.

getType() и сами типы теперь устарели в API уровня 28. Из Javadoc: 

Вызывающие абоненты должны переключиться на проверку NetworkCapabilities # hasTransport вместо одной из констант NetworkCapabilities # TRANSPORT *

Чтобы использовать NetworkCapabilities, вам нужно передать экземпляр Network методу getNetworkCapabilities(). Чтобы получить этот экземпляр, вам нужно вызвать getActiveNetwork(), который был добавлен на уровне API 23. 

Поэтому я считаю, что сейчас правильный способ безопасно проверить, подключены ли вы к Wi-Fi или сотовой сети:

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

Вы также можете проверить другие типы TRANSPORT, которые вы можете найти здесь

Важное примечание: если вы подключены к Wi-Fi и к VPN, текущим состоянием может быть TRANSPORT_VPN, поэтому вы можете также проверить его. 

Не забудьте добавить следующее разрешение в ваш файл AndroidManifest:

<uses-permission Android:name="Android.permission.ACCESS_NETWORK_STATE" />
9
pavelnazimok

Принятый ответ снова устарел в 28 (Android P), но его метод замены работает только на 23 (Android M). Для поддержки старых устройств я написал вспомогательную функцию.

Как пользоваться:

int type = getConnectionType(getApplicationContext());

Он возвращает int, вы можете изменить его на enum в своем коде:

0: Интернет недоступен (возможно, в режиме полета или в процессе подключения к Wi-Fi).

1: Сотовая связь (мобильные данные, 3G/4G/LTE и т.д.).

2: Wi-Fi.

Вы можете скопировать версию вспомогательной функции Kotlin или Java.

Котлин:

@IntRange(from = 0, to = 2)
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 {
        cm?.run {
            cm.activeNetworkInfo?.run {
                if (type == ConnectivityManager.TYPE_WIFI) {
                    result = 2
                } else if (type == ConnectivityManager.TYPE_MOBILE) {
                    result = 1
                }
            }
        }
    }
    return result
}

Джава:

@IntRange(from = 0, to = 2)
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 (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;
                }
            }
        }
    }
    return result;
}
6
user1032613

Как предложил Cheese Bread, используйте getActiveNetworkInfo ()

getActiveNetworkInfo

Добавлено на уровне API 1

NetworkInfo getActiveNetworkInfo ()

Возвращает сведения о текущей активной сети передачи данных по умолчанию. При подключении эта сеть является маршрутом по умолчанию для исходящих подключений. Вы должны всегда проверять isConnected () перед началом сетевого трафика. Это может вернуть ноль, если нет сети по умолчанию . Этот метод требует, чтобы вызывающая сторона держала разрешение ACCESS_NETWORK_STATE . Возвращает NetworkInfo объект NetworkInfo для текущей сети по умолчанию или ноль, если в настоящее время сеть по умолчанию не активна.

Ссылка: 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;
}

теперь вызовите метод, для безопасного использования попробуйте catch

     try {
     if(isInternetOn()){ //connected actions }
    else{
    //not connected actions }

        }catch (Exception e){
            Toast.makeText(this, e.getMessage(), Toast.LENGTH_SHORT).show();
        }

И не забудьте добавить:

    <uses-permission Android:name="Android.permission.ACCESS_NETWORK_STATE" />
3
Sanjoy Kanrar

Котлин версия:

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

Чтобы быть в безопасности, я бы предложил использовать также метод 

NetworkInfo.isConnected ()

Весь метод может быть таким, как показано ниже:

/**
 * 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;
    }
}
2
Vlad

Вот как я проверяю, использует ли текущая сеть сотовую связь в последних версиях Android:

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

(Почти) Все ответы устарели в Android P, так что вот решение C# ( за которым легко следовать Java-разработчикам )

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

Ключ здесь Android.Net.TransportType

0
Mehdi Dehghani

Хорошо проверить, подключена ли ваша сеть к Интернету:

@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
}
0
Anggrayudi H

Принятый ответ устарел в версии 28, так что вот решение, которое я использую в своем проекте.

Возвращает тип соединения. false: нет подключения к Интернету; правда: мобильный данные || Wi-Fi

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

Чтобы проверить, если вы онлайн

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

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
            }
        }
    }
}
0
M.Zain

Поскольку опубликованные ответы позволяют запрашивать только активную сеть, вот как получить NetworkInfo для любой сети, а не только для активной (например, для сети Wifi) (извините, код Kotlin впереди)

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

Для этого требуется API 21 или выше и разрешение Android.permission.ACCESS_NETWORK_STATE

0
m0skit0