Überprüfen Sie die Internetverbindung Android in Kotlin

Lesezeit: 6 Minuten

Benutzeravatar von Kakashi
Kakashi

Ich habe die Antwort von dieser versucht (die akzeptierte Antwort). Ich kann die “PING”-Methode verwenden, aber die Benutzeroberfläche wurde schwarz, da sie besagt, dass sie den UI-Thread blockiert. Es sah nicht gut aus und war störend, also habe ich versucht, die zweite Methode “Mit einem Socket im Internet verbinden” zu verwenden, aber ich weiß nicht, wie ich die Klasse in Kotlin verwenden soll.

Dies ist das Ergebnis der Konvertierung von Java in Kotlin durch Android Studio

package com.mockie.daikokuten.helpers

import android.os.AsyncTask.execute
import android.os.AsyncTask
import java.io.IOException
import java.net.InetSocketAddress
import java.net.Socket


internal class InternetCheck(private val mConsumer: Consumer) : AsyncTask<Void, Void, Boolean>() {
interface Consumer {
    fun accept(internet: Boolean?)
}

init {
    execute()
}

override fun doInBackground(vararg voids: Void): Boolean? {
    try {
        val sock = Socket()
        sock.connect(InetSocketAddress("8.8.8.8", 53), 1500)
        sock.close()
        return true
    } catch (e: IOException) {
        return false
    }

}

override fun onPostExecute(internet: Boolean?) {
    mConsumer.accept(internet)
}
}

aber ICH WEISS NICHT, WIE MAN ES BENUTZT. Ich habe es so versucht:

InternetCheck{ internet-> Log.d("test", "asdasdas") }

Es hat nicht funktioniert und führt zu einem Fehler. Da steht, ich muss “Verbraucher” passieren.

Meine Frage ist Wie man diese Klasse verwendet?

Benutzeravatar von Jorgesys
Jörgesys

Aktualisieren:
Seit Android 10 ist die Nutzung der Netzwerk information Klasse und ihre Methoden sind veraltet, jetzt müssen Sie die ConectivityManager-Klasse und verwenden getNetworkCapabilities () Methode aus Netzwerkfähigkeiten Klasse.

Wie überprüfe ich die Konnektivität in Android?

Kotlin :

fun isOnline(context: Context): Boolean {
    val connectivityManager =
        context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    if (connectivityManager != null) {
        val capabilities =
            connectivityManager.getNetworkCapabilities(connectivityManager.activeNetwork)
        if (capabilities != null) {
            if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
                Log.i("Internet", "NetworkCapabilities.TRANSPORT_CELLULAR")
                return true
            } else if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
                Log.i("Internet", "NetworkCapabilities.TRANSPORT_WIFI")
                return true
            } else if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET)) {
                Log.i("Internet", "NetworkCapabilities.TRANSPORT_ETHERNET")
                return true
            }
        }
    }
    return false
}

Java:

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

    if (connectivityManager != null) {
        NetworkCapabilities capabilities = connectivityManager.getNetworkCapabilities(connectivityManager.getActiveNetwork());
        if (capabilities != null) {
            if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
                Log.i("Internet", "NetworkCapabilities.TRANSPORT_CELLULAR");
                return true;
            } else if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
                Log.i("Internet", "NetworkCapabilities.TRANSPORT_WIFI");
                return true;
            } else if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET)) {
                Log.i("Internet", "NetworkCapabilities.TRANSPORT_ETHERNET");
                return true;
            }
        }
    }
    
    return false;
}

beide Methoden erfordern die Berechtigungen:

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

  • Antwort AKTUALISIERT, danke!

    – Jorgesys

    13. Oktober 2021 um 18:33 Uhr

  • Dies prüft nur, ob ein Netzwerk verfügbar ist, aber nicht, ob die Verbindung funktioniert. Wenn Sie beispielsweise mit Ihrem WLAN-Router verbunden sind, der Router jedoch vom Modem getrennt ist, wird dieser Code zurückgegeben true

    – Thanh Nguyen

    3. Oktober um 18:49 Uhr

Überprüfen Sie die Internetverbindung in Android Kotlin

fun isNetworkAvailable(context: Context?): Boolean {
    if (context == null) return false
    val connectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
        val capabilities = connectivityManager.getNetworkCapabilities(connectivityManager.activeNetwork)
        if (capabilities != null) {
            when {
                capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) -> {
                    return true
                }
                capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) -> {
                    return true
                }
                capabilities.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET) -> {
                    return true
                }
            }
        }
    } else {
        val activeNetworkInfo = connectivityManager.activeNetworkInfo
        if (activeNetworkInfo != null && activeNetworkInfo.isConnected) {
            return true
        }
    }
    return false
}

  • >= Build.VERSION_CODES.Q ist nicht Build.VERSION_CODES.M? Das sagte Linter in AndroidStudio

    – ejdrian313

    6. Juli 2020 um 6:46 Uhr

  • @ejdrian313 dies bedeutet, dass Ihre aktuelle Buildversion (M = Marshmallow, Android 5) unter Q (Android 10) liegt, was erforderlich ist, um den Code innerhalb der if-Anweisung auszuführen.

    – pentexnyx

    14. August 2020 um 22:14 Uhr

Rufen Sie die AsyncTask auf diese Weise auf, es sollte funktionieren. Sie müssen nichts in Ihrem InternetCheck AsyncTask ändern. Grundsätzlich müssen Sie ein Objekt übergeben, das die Consumer-Schnittstelle implementiert, die in der InternetCheck-Klasse definiert ist.

InternetCheck(object : InternetCheck.Consumer {
    override fun accept(internet: Boolean?) {
        Log.d("test", "asdasdas")
    }
})

 fun verifyAvailableNetwork(activity:AppCompatActivity):Boolean{
      val connectivityManager=activity.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
      val networkInfo=connectivityManager.activeNetworkInfo
      return  networkInfo!=null && networkInfo.isConnected
}

Überwachung der Internetverbindung in Echtzeit mit LiveData – Kotlin

Ich bin auf dieses erstaunliche gestoßen Lernprogramm auf Youtube. Wir müssen lediglich eine Hilfsdatei hinzufügen, die erweitert wird Lebensdaten und können es in unserer Aktivität oder unserem Fragment beobachten.

Verwendungszweck

    private lateinit var connectionLiveData: ConnectionLiveData

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityInternetConnectionTestBinding.inflate(layoutInflater)
        setContentView(binding.root)

        connectionLiveData = ConnectionLiveData(this)
        connectionLiveData.observe(this) { isNetworkAvailable ->
            isNetworkAvailable?.let {
                updateUI(it)
            }
        }
    }

Utility-Datei

const val TAG = "MyTagConnectionManager"

class ConnectionLiveData(context: Context) : LiveData<Boolean>() {

    private lateinit var networkCallback: ConnectivityManager.NetworkCallback
    private val connectivityManager =
        context.getSystemService(CONNECTIVITY_SERVICE) as ConnectivityManager
    private val validNetworks: MutableSet<Network> = HashSet()

    private fun checkValidNetworks() {
        postValue(validNetworks.size > 0)
    }

    override fun onActive() {
        networkCallback = createNetworkCallback()
        val networkRequest = NetworkRequest.Builder()
            .addCapability(NET_CAPABILITY_INTERNET)
            .build()
        connectivityManager.registerNetworkCallback(networkRequest, networkCallback)
    }

    override fun onInactive() {
        connectivityManager.unregisterNetworkCallback(networkCallback)
    }

    private fun createNetworkCallback() = object : ConnectivityManager.NetworkCallback() {

        override fun onAvailable(network: Network) {
            Log.d(TAG, "onAvailable: $network")
            val networkCapabilities = connectivityManager.getNetworkCapabilities(network)
            val hasInternetCapability = networkCapabilities?.hasCapability(NET_CAPABILITY_INTERNET)
            Log.d(TAG, "onAvailable: ${network}, $hasInternetCapability")

            if (hasInternetCapability == true) {
                // Check if this network actually has internet
                CoroutineScope(Dispatchers.IO).launch {
                    val hasInternet = DoesNetworkHaveInternet.execute(network.socketFactory)
                    if (hasInternet) {
                        withContext(Dispatchers.Main) {
                            Log.d(TAG, "onAvailable: adding network. $network")
                            validNetworks.add(network)
                            checkValidNetworks()
                        }
                    }
                }
            }
        }

        override fun onLost(network: Network) {
            Log.d(TAG, "onLost: $network")
            validNetworks.remove(network)
            checkValidNetworks()
        }
    }

    object DoesNetworkHaveInternet {

        fun execute(socketFactory: SocketFactory): Boolean {
            // Make sure to execute this on a background thread.
            return try {
                Log.d(TAG, "PINGING Google...")
                val socket = socketFactory.createSocket() ?: throw IOException("Socket is null.")
                socket.connect(InetSocketAddress("8.8.8.8", 53), 1500)
                socket.close()
                Log.d(TAG, "PING success.")
                true
            } catch (e: IOException) {
                Log.e(TAG, "No Internet Connection. $e")
                false
            }
        }
    }
}

Benutzeravatar von Syed Afeef
Syed Afeef

Fügen Sie diese Berechtigung oben im Manifest hinzu

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

und diese Funktion sollte es tun. Es wird basierend auf seiner Konnektivität einen booleschen Wert zurückgeben

fun isOnline(context: Context): Boolean {
    val cm = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        val n = cm.activeNetwork
        if (n != null) {
            val nc = cm.getNetworkCapabilities(n)
    //It will check for both wifi and cellular network
            return nc!!.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) || nc.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
        }
        return false
    } else {
        val netInfo = cm.activeNetworkInfo
        return netInfo != null && netInfo.isConnectedOrConnecting
    }
}

Es hat eine veraltete Methode sowie eine neueste Methode, die auf Ihrer API-Version basiert.

Vlads Benutzeravatar
Vlad

Kürzeste Version

val Context.isConnected: Boolean
    get() {
        return (getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager)
           .activeNetworkInfo?.isConnected == true
    }

  • Dies prüft nur, ob wir ein Netzwerk haben, nicht, ob wir “online” sind, dh mit dem Internet verbunden sind.

    – Lalle

    11. Juni 2019 um 15:21 Uhr

1432000cookie-checkÜberprüfen Sie die Internetverbindung Android in Kotlin

This website is using cookies to improve the user-friendliness. You agree by using the website further.

Privacy policy