Home » Android » Detect if Android device has Internet connection

Detect if Android device has Internet connection

Posted by: admin March 11, 2020 Leave a comment

Questions:

I need to tell if my device has Internet connection or not. I found many answers like:

private boolean isNetworkAvailable() {
    ConnectivityManager connectivityManager 
         = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
    return activeNetworkInfo != null;
}

(Taken from Detect whether there is an Internet connection available on Android.)

But this is not right, for example if I’m connected to a wireless network which doesn’t have Internet access, this method will return true… Is there a way to tell if the device has Internet connection and not if it is only connected to something?

How to&Answers:

You are right. The code you’ve provided only checks if there is a network connection.
The best way to check if there is an active Internet connection is to try and connect
to a known server via http.

public static boolean hasActiveInternetConnection(Context context) {
    if (isNetworkAvailable(context)) {
        try {
            HttpURLConnection urlc = (HttpURLConnection) (new URL("http://www.google.com").openConnection());
            urlc.setRequestProperty("User-Agent", "Test");
            urlc.setRequestProperty("Connection", "close");
            urlc.setConnectTimeout(1500); 
            urlc.connect();
            return (urlc.getResponseCode() == 200);
        } catch (IOException e) {
            Log.e(LOG_TAG, "Error checking internet connection", e);
        }
    } else {
        Log.d(LOG_TAG, "No network available!");
    }
    return false;
}

Of course you can substitute the http://www.google.com URL for any other server you want to connect to, or a server you know has a good uptime.

As Tony Cho also pointed out in this comment below, make sure you don’t run this code on the main thread, otherwise you’ll get a NetworkOnMainThread exception (in Android 3.0 or later). Use an AsyncTask or Runnable instead.

If you want to use google.com you should look at Jeshurun’s modification. In his answer he modified my code and made it a bit more efficient. If you connect to

HttpURLConnection urlc = (HttpURLConnection) 
            (new URL("http://clients3.google.com/generate_204")
            .openConnection());

and then check the responsecode for 204

return (urlc.getResponseCode() == 204 && urlc.getContentLength() == 0);

then you don’t have to fetch the entire google home page first.

Answer:

I have modified THelper’s answer slightly, to use a known hack that Android already uses to check if the connected WiFi network has Internet access. This is a lot more efficient over grabbing the entire Google home page. See here and here for more info.

public static boolean hasInternetAccess(Context context) {
    if (isNetworkAvailable(context)) {
        try {
            HttpURLConnection urlc = (HttpURLConnection) 
                (new URL("http://clients3.google.com/generate_204")
                .openConnection());
            urlc.setRequestProperty("User-Agent", "Android");
            urlc.setRequestProperty("Connection", "close");
            urlc.setConnectTimeout(1500); 
            urlc.connect();
            return (urlc.getResponseCode() == 204 &&
                        urlc.getContentLength() == 0);
        } catch (IOException e) {
            Log.e(TAG, "Error checking internet connection", e);
        }
    } else {
        Log.d(TAG, "No network available!");
    }
    return false;
}

Answer:

public boolean isInternetWorking() {
    boolean success = false;
    try {
        URL url = new URL("https://google.com");
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setConnectTimeout(10000);
        connection.connect();
        success = connection.getResponseCode() == 200;
    } catch (IOException e) {
        e.printStackTrace();
    }
    return success;
}

return true if internet is actually available

Make sure you have these two permission

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

if http does not work its because of the new android security they donot allow plain text communication now. for now just to by pass it.

android:usesCleartextTraffic=”true”

Answer:

If you’re targeting Lollipop or higher it’s possible to use the new NetworkCapabilities class, i.e:

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

    final Network network = connectivityManager.getActiveNetwork();
    final NetworkCapabilities capabilities = connectivityManager
            .getNetworkCapabilities(network);

    return capabilities != null
            && capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED);
}

Answer:

You don’t necessarily need to make a full HTTP connection. You could try just opening a TCP connection to a known host and if it succeeds you have internet connectivity.

public boolean hostAvailable(String host, int port) {
  try (Socket socket = new Socket()) {
    socket.connect(new InetSocketAddress(host, port), 2000);
    return true;
  } catch (IOException e) {
    // Either we have a timeout or unreachable host or failed DNS lookup
    System.out.println(e);
    return false;
  }
}

Then just check with:

boolean online = hostAvailable("www.google.com", 80);

Answer:

Based on the accepted answers, I have built this class with a listener so you can use it in the main thread:

First: InterntCheck class which checks for internet connection in the background then call a listener method with the result.

public class InternetCheck extends AsyncTask<Void, Void, Void> {


    private Activity activity;
    private InternetCheckListener listener;

    public InternetCheck(Activity x){

        activity= x;

    }

    @Override
    protected Void doInBackground(Void... params) {


        boolean b = hasInternetAccess();
        listener.onComplete(b);

        return null;
    }


    public void isInternetConnectionAvailable(InternetCheckListener x){
        listener=x;
        execute();
    }

    private boolean isNetworkAvailable() {
        ConnectivityManager connectivityManager = (ConnectivityManager) activity.getSystemService(CONNECTIVITY_SERVICE);
        NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
        return activeNetworkInfo != null;
    }
    private boolean hasInternetAccess() {
        if (isNetworkAvailable()) {
            try {
                HttpURLConnection urlc = (HttpURLConnection) (new URL("http://clients3.google.com/generate_204").openConnection());
                urlc.setRequestProperty("User-Agent", "Android");
                urlc.setRequestProperty("Connection", "close");
                urlc.setConnectTimeout(1500);
                urlc.connect();
                return (urlc.getResponseCode() == 204 &&
                        urlc.getContentLength() == 0);
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            Log.d("TAG", "No network available!");
        }
        return false;
    }

    public interface InternetCheckListener{
        void onComplete(boolean connected);
    }

}

Second: instantiate an instance of the class in the main thread and wait for the response (if you have worked with Firebase api for android before this should be familiar to you!).

new InternetCheck(activity).isInternetConnectionAvailable(new InternetCheck.InternetCheckListener() {

        @Override
        public void onComplete(boolean connected) {
           //proceed!
        }
    });

Now inside onComplete method you will get whether the device is connected to the internet or not.

Answer:

try this one

public class ConnectionDetector {
    private Context _context;

    public ConnectionDetector(Context context) {
        this._context = context;
    }

    public boolean isConnectingToInternet() {
        if (networkConnectivity()) {
            try {
                HttpURLConnection urlc = (HttpURLConnection) (new URL(
                        "http://www.google.com").openConnection());
                urlc.setRequestProperty("User-Agent", "Test");
                urlc.setRequestProperty("Connection", "close");
                urlc.setConnectTimeout(3000);
                urlc.setReadTimeout(4000);
                urlc.connect();
                // networkcode2 = urlc.getResponseCode();
                return (urlc.getResponseCode() == 200);
            } catch (IOException e) {
                return (false);
            }
        } else
            return false;

    }

    private boolean networkConnectivity() {
        ConnectivityManager cm = (ConnectivityManager) _context
                .getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo networkInfo = cm.getActiveNetworkInfo();
        if (networkInfo != null && networkInfo.isConnected()) {
            return true;
        }
        return false;
    }
}

you’ll have to add the following permission to your manifest file:

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

Then call like that:

if((new ConnectionDetector(MyService.this)).isConnectingToInternet()){
    Log.d("internet status","Internet Access");
}else{
    Log.d("internet status","no Internet Access");
}

Answer:

private static NetworkUtil mInstance;
private volatile boolean mIsOnline;

private NetworkUtil() {
    ScheduledExecutorService exec = Executors.newSingleThreadScheduledExecutor();
    exec.scheduleAtFixedRate(new Runnable() {
        @Override
        public void run() {
            boolean reachable = false;
            try {
                Process process = java.lang.Runtime.getRuntime().exec("ping -c 1 www.google.com");
                int returnVal = process.waitFor();
                reachable = (returnVal==0);
            } catch (Exception e) {
                e.printStackTrace();
            }
            mIsOnline = reachable;
        }
    }, 0, 5, TimeUnit.SECONDS);
}

public static NetworkUtil getInstance() {
    if (mInstance == null) {
        synchronized (NetworkUtil.class) {
            if (mInstance == null) {
                mInstance = new NetworkUtil();
            }
        }
    }
    return mInstance;
}

public boolean isOnline() {
    return mIsOnline;
}

Hope the above code helps you, also make sure you have internet permission in ur app.

Answer:

The latest way to do that from the documentation is to use the ConnectivityManager to query the active network and determine if it has Internet connectivity.

public boolean hasInternetConnectivity() {
    ConnectivityManager cm =
        (ConnectivityManager)context.getSystemService(Context.CONNECTIVITY_SERVICE);

    NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
    return (activeNetwork != null &&
                      activeNetwork.isConnectedOrConnecting());
}

Add these two permissions to your AndroidManifest.xml file:

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

Answer:

Check wifi type in connectivity manager:

   //check network connection
    ConnectivityManager cm = (ConnectivityManager) this.getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
    boolean hasNetworkConnection = activeNetwork != null && activeNetwork.isConnectedOrConnecting();
    System.out.println("Connection ? : " + hasNetworkConnection);
    //check wifi
    boolean hasWifiConnection = activeNetwork.getType() == ConnectivityManager.TYPE_WIFI;
    System.out.println("Wifi ? : " + hasWifiConnection);

Android Documentation describes ‘TYPE_WIFI’ as ‘A WIFI data connection. Devices may support more than one.’

Answer:

A nice solution to check if the active network have internet connection:

public boolean isNetworkAvailable(Context context) {
    ConnectivityManager connectivityManager
            = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    if (connectivityManager != null) {
        Network network = connectivityManager.getActiveNetwork();
        NetworkCapabilities networkCapabilities = connectivityManager.getNetworkCapabilities(network);
        return networkCapabilities != null && networkCapabilities
                .hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET);
    }
    return false;
}

Answer:

You can use ConnectivityManager.

val cm = getApplicationContext().getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
            val activeNetwork: NetworkInfo? = cm.activeNetworkInfo
            val dialogBuilder = AlertDialog.Builder(this)

            if (activeNetwork!=null) // Some network is available
            {
                if (activeNetwork.isConnected) { // Network is connected to internet

    }else{ // Network is NOT connected to internet

    }

Check this and this

Answer:

Use the following class, updated to the last API level: 29.

// License: MIT // http://opensource.org/licenses/MIT package net.i2p.android.router.util; import android.content.Context; import android.net.ConnectivityManager; import android.net.Network; import android.net.NetworkCapabilities; import android.net.NetworkInfo; import android.os.AsyncTask; import android.os.Build; import android.telephony.TelephonyManager; import java.io.IOException; import java.net.InetSocketAddress; import java.net.Socket; import java.net.UnknownHostException; import java.util.ArrayList; import java.util.concurrent.CancellationException; /** * Check device's network connectivity and speed. * * @author emil http://stackoverflow.com/users/220710/emil * @author str4d * @author rodrigo https://stackoverflow.com/users/5520417/rodrigo */ public class ConnectivityAndInternetAccessCheck { private static ArrayList < String > hosts = new ArrayList < String > () { { add("google.com"); add("facebook.com"); add("apple.com"); add("amazon.com"); add("twitter.com"); add("linkedin.com"); add("microsoft.com"); } }; /** * Get the network info. * * @param context the Context. * @return the active NetworkInfo. */ private static NetworkInfo getNetworkInfo(Context context) { NetworkInfo networkInfo = null; ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE); if (cm != null) { networkInfo = cm.getActiveNetworkInfo(); } return networkInfo; } /** * Gets the info of all networks * @param context The context * @return an array of @code{{@link NetworkInfo}} */ private static NetworkInfo[] getAllNetworkInfo(Context context) { ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE); return cm.getAllNetworkInfo(); } /** * Gives the connectivity manager * @param context The context * @return the @code{{@link ConnectivityManager}} */ private static ConnectivityManager getConnectivityManager(Context context) { return (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE); } /** * Check if there is any connectivity at all. * * @param context the Context. * @return true if we are connected to a network, false otherwise. */ public static boolean isConnected(Context context) { boolean isConnected = false; if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { ConnectivityManager connectivityManager = ConnectivityAndInternetAccessCheck.getConnectivityManager(context); Network[] networks = connectivityManager.getAllNetworks(); networksloop: for (Network network: networks) { if (network == null) { isConnected = false; } else { NetworkCapabilities networkCapabilities = connectivityManager.getNetworkCapabilities(network); if(networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)){ isConnected = true; break networksloop; } else { isConnected = false; } } } } else { NetworkInfo[] networkInfos = ConnectivityAndInternetAccessCheck.getAllNetworkInfo(context); networkinfosloop: for (NetworkInfo info: networkInfos) { // Works on emulator and devices. // Note the use of isAvailable() - without this, isConnected() can // return true when Wifi is disabled. // http://stackoverflow.com/a/2937915 isConnected = info != null && info.isAvailable() && info.isConnected(); if (isConnected) { break networkinfosloop; } } } return isConnected; } /** * Check if there is any connectivity to a Wifi network. * * @param context the Context. * @return true if we are connected to a Wifi network, false otherwise. */ public static boolean isConnectedWifi(Context context) { boolean isConnectedWifi = false; if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { ConnectivityManager connectivityManager = ConnectivityAndInternetAccessCheck.getConnectivityManager(context); Network[] networks = connectivityManager.getAllNetworks(); networksloop: for (Network network: networks) { if (network == null) { isConnectedWifi = false; } else { NetworkCapabilities networkCapabilities = connectivityManager.getNetworkCapabilities(network); if(networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)){ if (networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) { isConnectedWifi = true; break networksloop; } else { isConnectedWifi = false; } } } } } else { NetworkInfo[] networkInfos = ConnectivityAndInternetAccessCheck.getAllNetworkInfo(context); networkinfosloop: for (NetworkInfo n: networkInfos) { isConnectedWifi = n != null && n.isAvailable() && n.isConnected() && n.getType() == ConnectivityManager.TYPE_WIFI; if (isConnectedWifi) { break networkinfosloop; } } } return isConnectedWifi; } /** * Check if there is any connectivity to a mobile network. * * @param context the Context. * @return true if we are connected to a mobile network, false otherwise. */ public static boolean isConnectedMobile(Context context) { boolean isConnectedMobile = false; if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { ConnectivityManager connectivityManager = ConnectivityAndInternetAccessCheck.getConnectivityManager(context); Network[] allNetworks = connectivityManager.getAllNetworks(); networksloop: for (Network network: allNetworks) { if (network == null) { isConnectedMobile = false; } else { NetworkCapabilities networkCapabilities = connectivityManager.getNetworkCapabilities(network); if(networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)){ if (networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) { isConnectedMobile = true; break networksloop; } else { isConnectedMobile = false; } } } } } else { NetworkInfo[] networkInfos = ConnectivityAndInternetAccessCheck.getAllNetworkInfo(context); networkinfosloop: for (NetworkInfo networkInfo: networkInfos) { isConnectedMobile = networkInfo != null && networkInfo.isAvailable() && networkInfo.isConnected() && networkInfo.getType() == ConnectivityManager.TYPE_MOBILE; if (isConnectedMobile) { break networkinfosloop; } } } return isConnectedMobile; } /** * Check if there is fast connectivity. * * @param context the Context. * @return true if we have "fast" connectivity, false otherwise. */ public static boolean isConnectedFast(Context context) { boolean isConnectedFast = false; if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) { NetworkInfo[] networkInfos = ConnectivityAndInternetAccessCheck.getAllNetworkInfo(context); networkInfosloop: for (NetworkInfo networkInfo: networkInfos) { isConnectedFast = networkInfo != null && networkInfo.isAvailable() && networkInfo.isConnected() && isConnectionFast(networkInfo.getType(), networkInfo.getSubtype()); if (isConnectedFast) { break networkInfosloop; } } } else { throw new UnsupportedOperationException(); } return isConnectedFast; } /** * Check if the connection is fast. * * @param type the network type. * @param subType the network subtype. * @return true if the provided type/subtype combination is classified as fast. */ private static boolean isConnectionFast(int type, int subType) { if (type == ConnectivityManager.TYPE_WIFI) { return true; } else if (type == ConnectivityManager.TYPE_MOBILE) { switch (subType) { case TelephonyManager.NETWORK_TYPE_1xRTT: return false; // ~ 50-100 kbps case TelephonyManager.NETWORK_TYPE_CDMA: return false; // ~ 14-64 kbps case TelephonyManager.NETWORK_TYPE_EDGE: return false; // ~ 50-100 kbps case TelephonyManager.NETWORK_TYPE_EVDO_0: return true; // ~ 400-1000 kbps case TelephonyManager.NETWORK_TYPE_EVDO_A: return true; // ~ 600-1400 kbps case TelephonyManager.NETWORK_TYPE_GPRS: return false; // ~ 100 kbps case TelephonyManager.NETWORK_TYPE_HSDPA: return true; // ~ 2-14 Mbps case TelephonyManager.NETWORK_TYPE_HSPA: return true; // ~ 700-1700 kbps case TelephonyManager.NETWORK_TYPE_HSUPA: return true; // ~ 1-23 Mbps case TelephonyManager.NETWORK_TYPE_UMTS: return true; // ~ 400-7000 kbps /* * Above API level 7, make sure to set android:targetSdkVersion * to appropriate level to use these */ case TelephonyManager.NETWORK_TYPE_EHRPD: // API level 11 return true; // ~ 1-2 Mbps case TelephonyManager.NETWORK_TYPE_EVDO_B: // API level 9 return true; // ~ 5 Mbps case TelephonyManager.NETWORK_TYPE_HSPAP: // API level 13 return true; // ~ 10-20 Mbps case TelephonyManager.NETWORK_TYPE_IDEN: // API level 8 return false; // ~25 kbps case TelephonyManager.NETWORK_TYPE_LTE: // API level 11 return true; // ~ 10+ Mbps // Unknown case TelephonyManager.NETWORK_TYPE_UNKNOWN: default: return false; } } else { return false; } } public ArrayList < String > getHosts() { return hosts; } public void setHosts(ArrayList < String > hosts) { this.hosts = hosts; } //TODO Debug on devices /** * Checks that Internet is available by pinging DNS servers. */ private static class InternetConnectionCheckAsync extends AsyncTask < Void, Void, Boolean > { private Context context; /** * Creates an instance of this class * @param context The context */ public InternetConnectionCheckAsync(Context context) { this.setContext(context); } /** * Cancels the activity if the device is not connected to a network. */ @Override protected void onPreExecute() { if (!ConnectivityAndInternetAccessCheck.isConnected(getContext())) { cancel(true); } } /** * Tells whether there is Internet access * @param voids The list of arguments * @return True if Internet can be accessed */ @Override protected Boolean doInBackground(Void...voids) { return isConnectedToInternet(getContext()); } @Override protected void onPostExecute(Boolean aBoolean) { super.onPostExecute(aBoolean); } /** * The context */ public Context getContext() { return context; } public void setContext(Context context) { this.context = context; } } //network calls shouldn't be called from main thread otherwise it will throw //NetworkOnMainThreadException /** * Tells whether Internet is reachable * @return true if Internet is reachable, false otherwise * @param context The context */ public static boolean isInternetReachable(Context context) { try { return new InternetConnectionCheckAsync(context).execute().get(); } catch (CancellationException e) { e.printStackTrace(); } catch (Exception e) { e.printStackTrace(); } return false; } /** * Tells whether there is Internet connection * @param context The context * @return @code {true} if there is Internet connection */ private static boolean isConnectedToInternet(Context context) { boolean isAvailable = false; if (!ConnectivityAndInternetAccessCheck.isConnected(context)) { isAvailable = false; } else { try { foreachloop: for (String h: new ConnectivityAndInternetAccessCheck().getHosts()) { if (isHostAvailable(h)) { isAvailable = true; break foreachloop; } } } catch (IOException e) { e.printStackTrace(); } } return isAvailable; } /** * Checks if the host is available * @param hostName * @return * @throws IOException */ private static boolean isHostAvailable(String hostName) throws IOException { try (Socket socket = new Socket()) { int port = 80; InetSocketAddress socketAddress = new InetSocketAddress(hostName, port); socket.connect(socketAddress, 3000); return true; } catch (UnknownHostException unknownHost) { return false; } } } 

Answer:

You can do this using the ConnectivityManager API for android. It allows you to check whether you are connected to the internet and the type of internet connection you are connected to. Basically, Metered or Un-metered.

To check for internet connection.

ConnectivityManager cm = (ConnectivityManager)context.getSystemService(Context.CONNECTIVITY_SERVICE); NetworkInfo activeNetwork = cm.getActiveNetworkInfo(); boolean isConnected = activeNetwork != null && activeNetwork.isConnectedOrConnecting(); 

Documentation link: https://developer.android.com/training/monitoring-device-state/connectivity-status-type