ConnectivityManager getNetworkInfo (int) ist veraltet

143

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

getNetworkInfo(int)wurde in 23 veraltet. Der Vorschlag war, getAllNetworks()und getNetworkInfo(Network)stattdessen 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 , bevor jedoch die Herausforderung meiner Mindest API Anforderungen von 9 stellt ein Problem dar.

kyleED
quelle
Sie können die Build-Version zur Laufzeit überprüfen und die entsprechende Methode verwenden
stinepike
1
Wird dies immer noch eine veraltete Warnung auslösen?
Kyleed
Bitte überprüfen Sie meine ConnectivityObserver-Klasse, die API-Methoden unter und über Android Nougat kapselt.
JJD

Antworten:

165

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 Schaltergehäuse

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
}
Käse Brot
quelle
1
@ShirishHerwade - Ja, der Broadcast-Empfänger ist in diesem Fall nicht erforderlich. getActiveNetworkInfo () kann in einer eigenen Methode platziert werden, sofern eine Kontextreferenz enthalten ist.
Käsebrot
1
@TheIT - Ja doc sagt "Sie sollten immer isConnected () überprüfen, bevor Sie den Netzwerkverkehr initiieren". Diese Lösung initiiert keinen Datenverkehr und bietet nur eine Lösung für den veralteten Aufruf von getNetworkInfo ().
Käsebrot
7
Ab Android 9, SDK 28 ist dies nun veraltet.
Zbarcea Christian
32
activeNetwork.getType()ist veraltet und ConnectivityManager.TYPE_WIFIveraltet
Godwin
7
Ersatz ist jetztcm.getNetworkCapabilities(cm.activeNetwork).hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)
tmm1
63

Ab Oktober 2018 ist die akzeptierte Antwort veraltet.

getType()und Typen selbst sind jetzt in API Level 28 veraltet. Von Javadoc:

Anrufer sollten stattdessen die Überprüfung von NetworkCapabilities # hasTransport mit einer der Konstanten NetworkCapabilities # TRANSPORT * durchführen

Zur Verwendung NetworkCapabilitiesmüssen Sie eine NetworkInstanz an die getNetworkCapabilities()Methode übergeben. Um diese Instanz zu erhalten, müssen Sie aufrufen, getActiveNetwork()die in API Level 23 hinzugefügt wurde.

Daher glaube ich, dass der richtige Weg, um sicher zu überprüfen, ob Sie mit Wi-Fi oder einem Mobilfunknetz verbunden sind, Folgendes ist:

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 Arten von TRANSPORTsuchen, die Sie hier finden .

Wichtiger Hinweis: Wenn Sie mit Wi-Fi und einem VPN verbunden sind, kann Ihr aktueller Status sein TRANSPORT_VPN, daher möchten Sie möglicherweise auch danach suchen.

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

<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
pavelnazimok
quelle
Entspricht hasTransport (NetworkCapabilities.TRANSPORT_WIFI) ni.isConnected () && (ni.getType () == ConnnectivityManager.TYPE_WIFI)? Ich meine, überprüft die Funktion hasTransport () auch, ob das Gerät angeschlossen ist oder versucht, eine Verbindung herzustellen?
Keks
Wird erneut NetworkInfoabgeschrieben, können Sie nicht mehr verwenden NetWorkInfo, wie bietet dies also eine Alternative?
Prescott Chartier
@PrescottChartier Dieses Code-Snippet greift nur auf SDK <23-Geräten auf NetworkInfo zu
Tom
59

Update Februar 2020:

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

Wie benutzt man:

int type = getConnectionType(getApplicationContext());

Es gibt ein zurück int, das Sie enumin Ihrem Code ä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.

3: VPN

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

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;
}
user1032613
quelle
1
Da Sie 2 mögliche Ergebnisse haben, ist es besser, einen Booleschen Wert zu verwenden, anstatt eine Ganzzahl zurückzugeben ...
Christian
3
@Christian Wie im gelben Abschnitt erläutert, gibt diese Hilfsfunktion 3 mögliche Zustände zurück : No Internet, Cellularund Wi-Fi. Wenn Sie sich nicht für den Verbindungstyp interessieren, können Sie den Code an Ihre Anwendung anpassen.
user1032613
1
Was ist mit dem Kommentar in der obigen Lösung? "Wenn Sie mit Wi-Fi und einem VPN verbunden sind, könnte Ihr aktueller Status TRANSPORT_VPN sein, daher möchten Sie möglicherweise auch danach suchen."
David
1
@Lukas Sie müssen vorsichtig sein, wenn Sie eine BooleanWrapper-Klasse verwenden, booleandie primitiv ist. In der if-Anweisung müssen Sie check for hinzufügen null. Was ist auch, wenn morgen ein weiterer neuer Transportmodus in NetworkCapabilities eingeführt wird? Die Verwendung von Integer für die Verzweigung hilft also, und Sie können sich auch für Switch-Fälle entscheiden.
Shadow Droid
3
Segun Wahaab
16

Aktualisierte Antwort (19: 07: 2018):

Mit dieser Methode können Sie ü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:

Für eine optimale Wiederverwendung von Code improvisieren Sie die Antwort auf Käsebrot.

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 die Util-Klasse eingeordnet werden und kann verwendet werden, um zu überprüfen, ob das Telefon von einem beliebigen Teil Ihrer Anwendung aus über WLAN oder mobiles Internet mit dem Internet verbunden ist.

Nishanth Sreedhara
quelle
3
Ich würde vorschlagen, das aktive Netzwerk außerhalb der for-Schleife zu verschieben.
Shtolik
20
activeNetwork.isConnectedOrConnecting()ist jetzt veraltet
MHSFisher
1
Ich ändere activeNetwork.isConnectedOrConnecting () in activeNetwork.isConnected
Murillo Comino
NetworkInfo ist jetzt veraltet. Müssen noch einmal aktualisieren!
Scott Biggs
13

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

Gibt den Verbindungstyp zurück. false: keine Internetverbindung; true: mobile 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;
}
Rahul
quelle
2
activeNetwork.getType () ist ebenfalls veraltet. Sie können activeNetwork.isConnected () verwenden.
Aman Verma
11

Ab März 2020 gibt es ein Update für diese Antwort, das API.15 bis API.29 unterstützt. Sie finden es im Anschluss an die ursprüngliche Antwort

Antwort Februar 2019

So überprü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
            }
        }
    }
}

Für alle Fälle ist eine Berechtigung zum Zugriff auf den Netzwerkstatus erforderlich

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

Update März 2020

Da NetworkInfoes veraltet ist und ab API 29 von nun an ConnectivityManager.NetworkCallbackmit seiner Netzwerkstatusänderung onAvailable()und onLost()Rückrufen verwendet werden muss.

Verwendung:

  • Sie können diese Bibliothek entweder verwenden oder direkt die folgende Dienstprogrammklasse verwenden, die Teil dieser Bibliothek ist.

Eigenschaften

  • Es ist LifeCycle-bewusst, indem es implementiert wird LifecycleObserver, um Speicherverluste durch eine Bereinigung der onDestroy()Methode zu vermeiden .
  • Es unterstützt von API 15 (Ice Cream Sandwich) bis API 29 (Android Q)
  • Für APIs vor API 21 wird ein kontextbasiertes BoradcastReceiverund NetworkInfound verwendetConnectivityManager.NetworkCallback für API 21 und höher verwendet.
  • Wenn sowohl WLAN als auch Mobilfunknetze aktiviert sind, wird der Konnektivitäts-Listener nicht unterbrochen, wenn das WLAN während des Übergangs zum Mobilfunknetz getrennt wird.
  • Wenn das Mobilfunknetz eingeschaltet ist, wird der Konnektivitäts-Listener nicht unterbrochen, wenn das WLAN verbunden ist und das aktive Netzwerk ist (da dies das bevorzugte Netzwerk ist).
  • Wenn Sie die Bibliothek verwenden möchten, müssen Sie diese Berechtigung nicht android.permission.ACCESS_NETWORK_STATEangeben. Sie müssen es jedoch einschließen, wenn Sie die Utility-Klasse verwenden möchten.

Fähigkeiten

  • Ruft den aktuellen Konnektivitätsstatus ab (online / offline).
  • Kontinuierliches Überprüfen / Abhören der Internetverbindung und Auslösen eines Rückrufs, wenn das Gerät offline oder online geschaltet wird.
  • Holen Sie sich den Typ der aktiven Internetverbindung (WiFi oder Cellular).
  • Holen Sie sich den Typ aller verfügbaren Netzwerke (WiFi oder Cellular). >> Wird nur von API 21+ unterstützt
  • Abrufen der Anzahl aller verfügbaren Netzwerke >> Wird nur von API 21+ unterstützt
@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;
            }

        }

    }

}
Zain
quelle
@Rasel bitte überprüfen Sie die aktualisierte Antwort, hoffe es könnte helfen
Zain
Wenn der Benutzer gleichzeitig mit Wifi und mobilen Daten verbunden ist und die Verbindung in einem von ihnen verliert, onLostwird er angerufen. onLostbedeutet nicht, dass das Gerät die Internetverbindung verloren hat, aber ein Netzwerk hat die Verbindung verloren.
Gokhan Arik
@ Gokhan Arik .. Netter Fang Ich arbeite daran, es zu lösen
Zain
1
Überprüfen Sie diese Diskussion gist.github.com/PasanBhanu/730a32a9eeb180ec2950c172d54bb06a
Gokhan Arik
@ GokhanArik danke für die Hilfe .. Ich habe gerade meine Antwort aktualisiert und die API-Nutzung erweitert. Bitte lassen Sie mich wissen, wenn Sie Fehler bemerken
Zain
4

Überprüfen Sie, 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
}
Anggrayudi H.
quelle
Vielleicht möchten Sie auch überprüfen NetworkCapabilities.NET_CAPABILITY_VALIDATED.
JJD
3

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
}
SANAT
quelle
3

Verwenden Sie getActiveNetworkInfo (), wie von Cheese Bread vorgeschlagen.

getActiveNetworkInfo

In API-Ebene 1 hinzugefügt

NetworkInfo getActiveNetworkInfo ()

Gibt Details zum aktuell aktiven Standarddatennetz 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. Für diese Methode muss der Aufrufer über die Berechtigung ACCESS_NETWORK_STATE verfügen. Gibt NetworkInfo ein NetworkInfo-Objekt für das aktuelle Standardnetzwerk zurück oder null, wenn derzeit 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. Versuchen Sie zur sicheren Verwendung catch

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 hinzuzufügen:

<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
Sanjoy Kanrar
quelle
Danke, es ist nützlich. Wenn wir den Netzwerkstatus überprüfen und wenn sowohl WLAN als auch Daten ausgeschaltet sind, stürzt die App zu diesem Zeitpunkt ab, aber versuchen Sie, das Problem zu lösen.
Rucha Bhatt Joshi
Dies funktioniert jedoch nicht, wenn ich überprüfen möchte, ob ein bestimmter Netzwerktyp vorhanden ist. getNetworkInfo(ConnectivityManager.TYPE_ETHERNET).isAvailable
Zählen Sie
3
getState () veraltet!
Diego Venâncio
Mehrere veraltete Anweisungen!
Scott Biggs
2

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

NetworkInfo.isConnected ()

Die gesamte Methode könnte wie folgt aussehen:

/**
 * 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;
    }
}
Vlad
quelle
9
activeNetwork.getType()ist veraltet und ConnectivityManager.TYPE_WIFI veraltet
Godwin
2

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

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
    }
}
tmm1
quelle
2

(Fast) Alle Antworten sind in Android P veraltet. Hier ist eine C#Lösung ( die für Java-Entwickler leicht zu befolgen 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

Mehdi Dehghani
quelle
Aaaannnndddd alles in diesem ist DEPRECIATED!
Prescott Chartier
@ PrescottChartier in welcher Version?
Mehdi Dehghani
2

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 schreiben Context. Unten sind meine Helfer-Erweiterungen für Contextund 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)
Sagar Chapagain
quelle
2

Überprüfen Sie, ob 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
}
Alireza Tizfahm Fard
quelle
2

ConnectivityManager.getActiveNetwork () wird unter Android M (API 28) nicht gefunden. networkInfo.getState () ist über Android L veraltet.

Die endgültige Antwort lautet also:

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;
}
Vidha
quelle
1
Sie sagen, getActiveNetwork () ist in Android unter M nicht zu finden, aber Ihr Code verwendet es auf Lollipop !?
3c71
2

Viele Antworten verwenden immer noch getNetworkType unter 23, was veraltet ist. Verwenden Sie den folgenden Code, um zu überprüfen, ob das Gerät über eine Internetverbindung verfügt.

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

..

Vergessen Sie nicht, diese Zeile in Manifest einzufügen

<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
Nilesh Rathore
quelle
1

Da Sie mit den veröffentlichten Antworten nur das aktive Netzwerk abfragen können, erfahren Sie hier, wie Sie NetworkInfofür jedes Netzwerk und nicht nur für das aktive Netzwerk (z. B. Wifi-Netzwerk) zugreifen können (Entschuldigung, Kotlin-Code voraus).

(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

m0skit0
quelle
1
currentNetwork.getType () und ConnectivityManager.TYPE_WIFI sind beide in API 28 veraltet.
Abushawish
@Abushawish Was ist die empfohlene Lösung für API 28?
tmm1
Ersatz ist jetztcm.getNetworkCapabilities(cm.activeNetwork).hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)
tmm1
1

NetManager , mit dem Sie die Internetverbindung unter Android mit Kotlin überprüfen können

Wenn Sie minSdkVersion> = 23 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 <23 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) }
    }
}
Cube Studio
quelle
1

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

Bitte folgen Sie diesem Tutorial, es sollte jedem helfen, der nach Antworten sucht.

Beachten Sie, dass networkInfo veraltet ist. Ersetzen Sie daher isNetworkReacheable () durch die Antwort @vidha, indem Sie getApplicationContext () als Parameter übergeben

  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;
}
Commitware
quelle
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();
    }
}
Syed Zeeshan
quelle
0

Das funktioniert bei mir in Kotlin. Viele APIs sind in der Network Manager-Klasse veraltet, sodass die folgende Antwort die gesamte API-Unterstützung abdeckt.

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
}

Sie werden auch unten hinzufügen

<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
Alok Gupta
quelle
0

Der folgende Code funktioniert auf allen APIs. (Kotlin)

GetActiveNetworkInfo () ist jedoch nur in API 29 veraltet und funktioniert auf allen APIs, sodass wir es in allen APIs unter 29 verwenden können

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
        }
Gowtham. R.
quelle
0

Etwas wie das:

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

Und im Hauptprogrammkörper:

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();
Андрей Иванов
quelle
0

Dies funktioniert auch in Android 10. Es wird true zurückgegeben, wenn eine Verbindung zum Internet besteht. Andernfalls wird false zurückgegeben.

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
    }
Shylendra Madda
quelle