AndroidUtil - 基于Android网络连接状态全面深度检查

一个通用的完整网络连接状态检查工具

netState，ping dns，http

异步执行

使用低级api，保持独立通用

public class NetworkChecker {

    private static final String TAG = "NetWorkChecker";

    private static final String DNS_GOOGLE = "8.8.8.8";
    private static final String DNS_DIANXIN = "114.114.114.114";
    private static final String URL_BAIDU = "http://www.baidu.com";
    private static final String URL_TENCENT = "http://www.qq.com";
    private static boolean sPingSuccess = false;
    private static boolean sHttpSuccess = false;
    private static boolean sChecking = false;       //当前是否正在检查网络中
    private static ArrayList<checkEndListener> listeners = new ArrayList<>();

    public interface checkEndListener {
        public void onResult(boolean isNetWorkOk);
    }

    /**
     * 检查网络的方法，通过网络回调来判断当前的网络是否是联通的
     *
     * @param listener
     */
    public static synchronized void doCheck(Context context, final checkEndListener listener) {
        Log.i(TAG, "doCheck start, sChecking = " + sChecking);
        if (null == listener) {
            Log.i(TAG, "listener is null , do nothing");
            return;
        }

        listeners.add(listener);

        if (sChecking) {
            Log.i(TAG, "listener is checking , return and wait");
            return;
        }
        if (!isNetworkConnected(context)) {
            Log.i(TAG, " network is not connected, onCheckResult and return");
            onCheckResult(false);
            return;
        }

        sChecking = true;
        sHttpSuccess = false;
        sPingSuccess = false;
        pingCheckAll(new checkEndListener() {
            @Override
            public void onResult(boolean isNetWorkOk) {
                if (isNetWorkOk) {
                    Log.i(TAG, "ping success");
                    sPingSuccess = true;
                    if (sHttpSuccess) {
                        Log.i(TAG, " http check already end ,and success,so network is ok");
                        onCheckResult(true);
                    }
                } else if (sChecking) {
                    Log.i(TAG, " ping error, so network is not ok");
                    onCheckResult(false);
                }
            }
        });
        httpCheckall(new checkEndListener() {
            @Override
            public void onResult(boolean isNetWorkOk) {
                if (isNetWorkOk) {
                    Log.i(TAG, "http success");
                    sHttpSuccess = true;
                    if (sPingSuccess) {
                        Log.i(TAG, " ping check already end ,and success,so network is ok");
                        onCheckResult(true);
                    }
                } else if (sChecking) {
                    Log.i(TAG, " http error, so network is not ok");
                    onCheckResult(false);
                }
            }
        });
    }

    private static synchronized void onCheckResult(boolean b) {
        Log.i(TAG, "-- onCheckResult result = " + b);
        if (!listeners.isEmpty()) {
            for (checkEndListener listener: listeners) {
                listener.onResult(b);
            }
            listeners.clear();
        }
        sChecking = false;
    }

    /**
     * 检查谷歌和电信的两者的DNS是否能ping通
     *
     * @param listener 检查结果的回调
     */
    private static void pingCheckAll(final checkEndListener listener) {
        pingCheck(new checkEndListener() {
            @Override
            public void onResult(boolean isNetWorkOk) {
                if (isNetWorkOk) {
                    Log.i(TAG, " ping dianxin success");
                    listener.onResult(true);
                } else {
                    Log.i(TAG, "ping dianxin error,now ping google");
                    pingCheck(new checkEndListener() {
                        @Override
                        public void onResult(boolean isNetWorkOk) {
                            if (isNetWorkOk) {
                                Log.i(TAG, "ping google success");
                                listener.onResult(true);
                            } else {
                                Log.i(TAG, "ping goolgle error");
                                listener.onResult(false);
                            }
                        }
                    }, DNS_GOOGLE);
                }
            }
        }, DNS_DIANXIN);
    }

    /**
     * 检查单个域名是否能ping通
     *
     * @param listener ping结果的回调
     * @param ip       需要ping的ip
     */
    private static void pingCheck(final checkEndListener listener, final String ip) {
        new Thread() {
            public void run() {
                String cmdStr = "ping -c 5 -w 10";
                Process process = null;

                BufferedReader inReader = null;
                BufferedReader errorReader = null;
                try {
                    process = Runtime.getRuntime().exec(cmdStr + " " + ip);
                    int status = process.waitFor();

                    inReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
                    errorReader = new BufferedReader(new InputStreamReader(process.getErrorStream()));

                    String line = "";
                    StringBuffer buffer = new StringBuffer();
                    StringBuffer errorBuffer = new StringBuffer();
                    while ((line = inReader.readLine()) != null) {
                        buffer.append(line);
                        Log.i(TAG, line);
                    }

                    line = "";
                    while ((line = errorReader.readLine()) != null) {
                        errorBuffer.append(line);
                        Log.i(TAG, "error:" + line);
                    }

                    Log.i(TAG, "status=" + status);

                    String resultStr = buffer.toString();

                    if (!TextUtils.isEmpty(resultStr)) {
                        if (!resultStr.contains("100%")) {
                            if (listener != null) {
                                listener.onResult(true);
                                return;
                            }
                        }
                    }
                } catch (Exception e) {
                    Log.i(TAG, "IOException:" + e.getMessage());
                } finally {
                    if (process != null) {
                        process.destroy();
                    }

                    Tools.close(inReader);
                    Tools.close(errorReader);
                }

                if (listener != null) {
                    listener.onResult(false);
                }
            }
        }.start();
    }

    private static void httpCheckall(final checkEndListener listener) {
        httpCheck(new checkEndListener() {
            @Override
            public void onResult(boolean isNetWorkOk) {
                if (isNetWorkOk) {
                    Log.i(TAG, " http baidu success");
                    listener.onResult(true);
                } else {
                    Log.i(TAG, "http baidu error, now http tencent");
                    httpCheck(new checkEndListener() {
                        @Override
                        public void onResult(boolean isNetWorkOk) {
                            if (isNetWorkOk) {
                                Log.i(TAG, "http tencent success");
                                listener.onResult(true);
                            } else {
                                Log.i(TAG, "http tencent error");
                                listener.onResult(false);
                            }
                        }
                    }, URL_TENCENT);
                }
            }
        }, URL_BAIDU);
    }

    private static void httpCheck(final checkEndListener l, final String Url) {
        new Thread() {
            public void run() {
                Log.i(TAG, "httpCheck, url:" + Url);
                if (null == Url) {
                    Log.e(TAG, "fatal error, url is null");
                    l.onResult(false);
                    return;
                }
                HttpURLConnection urlConnection = null;
                try {
                    URL url = new URL(Url.trim());
                    //打开连接
                    urlConnection = (HttpURLConnection) url.openConnection();
                    urlConnection.setRequestMethod("GET");
                    urlConnection.setDoOutput(false);
                    urlConnection.setDoInput(true);
                    urlConnection.setConnectTimeout(5000);
                    urlConnection.setReadTimeout(5000);
                    urlConnection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
                    urlConnection.connect();
                    int code = urlConnection.getResponseCode();
                    Log.i(TAG, " http response code is " + code);
                    if (code == HttpURLConnection.HTTP_OK) {
                        //得到输入流
                        Log.i(TAG, "Http check success");
                        l.onResult(true);
                        urlConnection.disconnect();
                        return;
                    }
                } catch (Exception e) {
                    Log.i(TAG, "Http exception:" + e.getMessage());
                    if (urlConnection != null) {
                        urlConnection.disconnect();
                    }
                }
                l.onResult(false);
            }
        }.start();
    }

    /**
     * 判断网络是否已经连接，当调用整机的方法出现异常的时候，返回true 由ping和http来判断
     *
     * @param context
     * @return
     */
    public static boolean isNetworkConnected(Context context) {
        try{
            ConnectivityManager connectivityManager = (ConnectivityManager) context.getApplicationContext()
                    .getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo networkInfo = null;
            if (connectivityManager != null) {
                networkInfo = connectivityManager.getActiveNetworkInfo();
            }
            return ((networkInfo != null) && networkInfo.isConnected());
        }catch(Exception e){
            Log.e(TAG," isNetworkConnect exception:"+e.getMessage());
            return true;
        }
    }
}