it-swarm.com.de

ConnectivityManager getNetworkInfo (int) nicht mehr unterstützt

Verwenden Sie compileSdkVersion 23, versuchen Sie jedoch bereits 9 zu unterstützen.

getNetworkInfo (int) wurde in 23 nicht mehr unterstützt. Der Vorschlag lautete, stattdessen getAllNetworks und getNetworkInfo (Network) zu verwenden. Für beide ist jedoch mindestens API 21 erforderlich.

Gibt es eine Klasse, die wir im Support-Paket verwenden können, um dies zu unterstützen?

Ich weiß, dass eine Lösung vorgeschlagen wurde vorher , jedoch stellt die Herausforderung meiner Mindest-API-Anforderungen von 9 ein Problem dar.

75
kyleED

Sie können verwenden:

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
        }

Oder in einem Schalterfall

        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

Aktualisierte Antwort (19: 07: 2018):

Diese Methode hilft Ihnen zu überprüfen, ob die Internetverbindung verfügbar ist.

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

Alte Antwort:

Um die beste Wiederverwendung von Code zu erreichen, improvisieren Sie die Käsebrot-Antwort.

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

Der Code kann in der Util-Klasse abgelegt werden und kann verwendet werden, um zu überprüfen, ob das Telefon über Wifi oder Mobile Internet mit einem Teil Ihrer Anwendung mit dem Internet verbunden ist.

14

Für Oktober 2018 wird die akzeptierte Antwort nicht mehr empfohlen.

getType() und die Typen selbst werden in API Level 28 nicht mehr unterstützt. Von Javadoc: 

Anrufer sollten stattdessen zur Überprüfung von NetworkCapabilities # hasTransport mit einer der NetworkCapabilities # TRANSPORT * -Konstanten wechseln

Um NetworkCapabilities verwenden zu können, müssen Sie eine Network-Instanz an die getNetworkCapabilities()-Methode übergeben. Um diese Instanz zu erhalten, müssen Sie getActiveNetwork() aufrufen, das in API Level 23 hinzugefügt wurde. 

Ich glaube, jetzt ist der richtige Weg, um sicher zu prüfen, ob Sie mit einem WLAN oder einem Mobilfunknetz verbunden sind, Folgendes:

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

Sie können auch nach anderen Typen von TRANSPORT suchen, die Sie hier finden können. 

Wichtiger Hinweis: Wenn Sie mit Wi-Fi verbunden sind, und mit einem VPN, können Sie den aktuellen Status TRANSPORT_VPN eingeben. 

Vergessen Sie nicht, Ihrer AndroidManifest-Datei die folgende Berechtigung hinzuzufügen:

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

Die akzeptierte Antwort ist wieder veraltet in 28 (Android P), aber ihre Ersetzungsmethode funktioniert nur bei 23 (Android M). Um ältere Geräte zu unterstützen, habe ich eine Hilfsfunktion geschrieben.

Wie benutzt man:

int type = getConnectionType(getApplicationContext());

Es gibt eine int zurück, die Sie in Ihrem Code in enum ändern können:

0: Kein Internet verfügbar (möglicherweise im Flugzeugmodus oder beim Beitritt zu einem WLAN).

1: Mobilfunk (mobile Daten, 3G/4G/LTE, was auch immer).

2: Wi-Fi.

Sie können entweder die Kotlin- oder die Java-Version der Hilfsfunktion kopieren.

Kotlin:

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

Java:

@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

Wenn Käsebrot vorgeschlagen wird, verwenden Sie getActiveNetworkInfo ()

getActiveNetworkInfo

In API Level 1 hinzugefügt

NetworkInfo getActiveNetworkInfo ()

Gibt Details zum derzeit aktiven Standarddatennetzwerk zurück. Wenn eine Verbindung besteht, ist dieses Netzwerk die Standardroute für ausgehende Verbindungen. Sie sollten immer isConnected () überprüfen, bevor Sie den Netzwerkverkehr starten. Dies kann Null zurückgeben, wenn kein Standardnetzwerk vorhanden ist. Diese Methode erfordert, dass der Aufrufer die Berechtigung ACCESS_NETWORK_STATE ..__ besitzt. Kehrt zurück Netzwerk information ein NetworkInfo-Objekt für das aktuelle Standardnetzwerk oder null, wenn zurzeit kein Standardnetzwerk aktiv ist.

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

rufen Sie jetzt die Methode auf, probieren Sie catch für die sichere Verwendung

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

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

Und vergessen Sie nicht folgendes hinzuzufügen:

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

Kotlin-Version:

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

Möglicherweise müssen wir die Internetverbindung mehrmals überprüfen. So wird es für uns einfacher, wenn wir den Codeblock in einer Erweiterungsmethode von Context schreiben. Unten sind meine Helfererweiterungen für Context und Fragment.

Überprüfen der Internetverbindung

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

Andere Erweiterungen

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

überprüfen Sie, ob das Internet verfügbar ist

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

Um auf der sicheren Seite zu sein, würde ich vorschlagen, auch Methode zu verwenden 

NetworkInfo.isConnected ()

Die ganze Methode könnte wie folgt sein:

/**
 * 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
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();
    }
}
1
Syed Zeeshan

So überprüfe ich, ob das aktuelle Netzwerk Mobilfunk oder die neuesten Android-Versionen verwendet:

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

(Fast) Alle Antworten sind in Android P veraltet, daher ist hier C# Lösung ( die für Java-Entwickler leicht zu folgen ist )

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

Der Schlüssel hier ist Android.Net.TransportType

0
Mehdi Dehghani

Es ist gut zu überprüfen, ob Ihr Netzwerk mit dem Internet verbunden ist:

@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

Die akzeptierte Antwort ist in Version 28 veraltet, daher ist hier die Lösung, die ich in meinem Projekt verwende.

Gibt den Verbindungstyp zurück. false: keine Internetverbindung; wahr: mobil Daten || W-lan

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

So prüfen Sie, ob Sie online sind:

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

Um die Art der Internetverbindung vor/nach Android M zu erhalten

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

Da die Antworten nur das aktive Netzwerk abfragen, können Sie NetworkInfo für jedes Netzwerk verwenden, nicht nur für das aktive Netzwerk (z. B. WLAN-Netzwerk).

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

Dies erfordert API 21 oder höher und die Berechtigung Android.permission.ACCESS_NETWORK_STATE

0
m0skit0

NetManager Mit Kotlin können Sie die Internetverbindung auf Android überprüfen

Wenn Sie minSdkVersion> = 2 verwenden

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

Wenn Sie minSdkVersion <2 verwenden

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) }
    }
}
0
Cube Studio