Android中调用Ping操作及结果分析

实现方法

android中调用ping命令需要使用Linux底层的命令：

ping -c 1 -w 10 ip

其中参数-c 1指的是ping的次数为1，参数-w 10指的是超时时间，单位为秒，超过10s则本次ping失败。
参数ip指的是ip地址。

Android中调用ping的方法如下：

Process process = Runtime.getRuntime().exec("ping -c 1 -w 10 " + ip);       //执行ping指令

结果解析

调用ping之后的结果(以百度为例)打印如下：

PING www.baidu.com (220.181.38.150) 56(84) bytes of data.
    64 bytes from 220.181.38.150: icmp_seq=1 ttl=254 time=9.33 ms
    
    --- www.baidu.com ping statistics ---
    1 packets transmitted, 1 received, 0% packet loss, time 0ms
    rtt min/avg/max/mdev = 9.333/9.333/9.333/0.000 ms

可以从其中看到本次结果的ttl,时间，丢包率等数值。

获取到ping的时间：结果中包含有几项计算的最大，最小和平均时间min/avg/max/mdev（mdev为时间偏差），我们可以分割字符串进行解析：

    /**
     * 获取ping url的RTT
     *
     * @param url     需要ping的url地址
     * @param type    ping的类型
     * @param count   需要ping的次数
     * @param timeout 需要ping的超时时间，单位 ms
     * @return RTT值，单位 ms 注意：-1是默认值，返回-1表示获取失败
     */
    public static int getRTT(String url, int type, int count, int timeout) {
        String domain = getDomain(url);
        if(null == domain){
            return -1;
        }
        String pingString = ping(createSimplePingCommand(count, timeout, domain));
        Logger.d(pingString);
        if (null != pingString) {
            try {
                //获取以"min/avg/max/mdev"为头的文本，分别获取此次的ping参数
                String tempInfo = pingString.substring(pingString.indexOf("min/avg/max/mdev") + 19);
                String[] temps = tempInfo.split("/");
                switch (type) {
                    case TYPE_MIN: {
                        return Math.round(Float.parseFloat(temps[0]));
                    }
                    case TYPE_AVG: {
                        return Math.round(Float.parseFloat(temps[1]));
                    }
                    case TYPE_MAX: {
                        return Math.round(Float.parseFloat(temps[2]));
                    }
                    case TYPE_MDEV: {
                        return Math.round(Float.parseFloat(temps[3]));
                    }
                    default: {
                        return -1;
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return -1;
    }

获取到其中的丢包率，同样通过分割字符串实现：

    /**
     * 获取ping url的丢包率
     *
     * @param url     需要ping的url地址
     * @param count   需要ping的次数
     * @param timeout 需要ping的超时时间，单位ms
     * @return 丢包率 x%
     */
    public static String getPacketLoss(String url, int count, int timeout) {
        String domain = getDomain(url);
        if (null == domain) {
            return null;
        }
        String pingString = ping(createSimplePingCommand(count, timeout, domain));
        if (null != pingString) {
            try {
                String tempInfo = pingString.substring(pingString.indexOf("received,"));
                return tempInfo.substring(9, tempInfo.indexOf("packet"));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }

工具类完整代码

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URI;
import java.util.regex.Pattern;

public class PingUtil {

    //ip地址正则表达式
    private static final String ipRegex =
            "((?:(?:25[0-5]|2[0-4]\\d|((1\\d{2})|([1-9]?\\d)))\\.){3}(?:25[0-5]|2[0-4]\\d|((1\\d{2})|([1-9]?\\d))))";

    //默认超时时间
    private static final int TIME_OUT = 100;
    //默认ping的次数
    private static final int DEFAULT_COUNT = 1;

    //最小RTT
    private static final int TYPE_MIN = 1;
    //平均RTT
    private static final int TYPE_AVG = 2;
    //最大RTT
    private static final int TYPE_MAX = 3;
    //RTT偏差
    private static final int TYPE_MDEV = 4;

    //网络ping的结果
    private static final String RESULT_BAD = "bad";
    private static final String RESULT_NORMAL = "normal";
    private static final String RESULT_GOOD = "good";

    /**
     * 解析数据，延迟小于50为good，延迟在50~100之间或者丢包率为0为normal，
     * 延迟在100以上或者返回失败或丢包率大于0，则返回bad
     *
     * @param url ping的地址
     * @return
     */
    public static String parseRTT(String url) {
        int pingRtt = getRTT(url);
        float pingLostRate = getPacketLossFloat(url);
        if (pingRtt > 0 && pingRtt < 50) {
            return RESULT_GOOD;
        } else if ((pingRtt <= 100 && pingRtt > 50) || pingLostRate == 0) {
            return RESULT_NORMAL;
        } else if (pingRtt > 100 || pingRtt < 0 || pingLostRate > 0) {
            return RESULT_BAD;
        }
        return RESULT_BAD;
    }

    /**
     * 解析数据，延迟小于50为good，延迟在50~100之间或者丢包率为0为normal，
     * 延迟在100以上或者返回失败或丢包率大于0，则返回bad
     *
     * @param url     ping的地址
     * @param type    ping的类型
     * @param count   ping的次数
     * @param timeout ping的超时时间
     * @return
     */
    public static String parseRTT(String url, int type, int count, int timeout) {
        int pingRtt = getRTT(url, type, count, timeout);
        float pingLostRate = getPacketLossFloat(url, count, timeout);
        if (pingRtt > 0 && pingRtt < 50) {
            return RESULT_GOOD;
        } else if ((pingRtt <= 100 && pingRtt > 50) || pingLostRate == 0) {
            return RESULT_NORMAL;
        } else if (pingRtt > 100 || pingRtt < 0 || pingLostRate > 0) {
            return RESULT_BAD;
        }
        return RESULT_BAD;
    }

    /**
     * 获取pingPTT值，默认为平均RTT
     *
     * @param url 需要ping的url地址
     * @return RTT值，单位 ms 注意：-1是默认值，返回-1表示获取失败
     */
    public static int getRTT(String url) {
        return getRTT(url, TYPE_AVG);
    }

    /**
     * 获取ping的RTT值
     *
     * @param url  需要ping的url地址
     * @param type ping的类型
     * @return RTT值，单位 ms 注意：-1是默认值，返回-1表示获取失败
     */
    public static int getRTT(String url, int type) {
        return getRTT(url, type, DEFAULT_COUNT, TIME_OUT);
    }

    /**
     * 获取ping url的RTT
     *
     * @param url     需要ping的url地址
     * @param type    ping的类型
     * @param count   需要ping的次数
     * @param timeout 需要ping的超时时间，单位 ms
     * @return RTT值，单位 ms 注意：-1是默认值，返回-1表示获取失败
     */
    public static int getRTT(String url, int type, int count, int timeout) {
        String domain = getDomain(url);
        if(null == domain){
            return -1;
        }
        String pingString = ping(createSimplePingCommand(count, timeout, domain));
        Logger.d(pingString);
        if (null != pingString) {
            try {
                //获取以"min/avg/max/mdev"为头的文本，分别获取此次的ping参数
                String tempInfo = pingString.substring(pingString.indexOf("min/avg/max/mdev") + 19);
                String[] temps = tempInfo.split("/");
                switch (type) {
                    case TYPE_MIN: {
                        return Math.round(Float.parseFloat(temps[0]));
                    }
                    case TYPE_AVG: {
                        return Math.round(Float.parseFloat(temps[1]));
                    }
                    case TYPE_MAX: {
                        return Math.round(Float.parseFloat(temps[2]));
                    }
                    case TYPE_MDEV: {
                        return Math.round(Float.parseFloat(temps[3]));
                    }
                    default: {
                        return -1;
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return -1;
    }

    /**
     * 获取ping url的丢包率，浮点型
     *
     * @param url 需要ping的url地址
     * @return 丢包率 如50%可得 50，注意：-1是默认值，返回-1表示获取失败
     */
    public static float getPacketLossFloat(String url) {
        String packetLossInfo = getPacketLoss(url);
        if (null != packetLossInfo) {
            try {
                return Float.parseFloat(packetLossInfo.replace("%", ""));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return -1;
    }

    /**
     * 获取ping url的丢包率，浮点型
     *
     * @param url     需要ping的url地址
     * @param count   需要ping的次数
     * @param timeout 需要ping的超时时间，单位 ms
     * @return 丢包率 如50%可得 50，注意：-1是默认值，返回-1表示获取失败
     */
    public static float getPacketLossFloat(String url, int count, int timeout) {
        String packetLossInfo = getPacketLoss(url, count, timeout);
        if (null != packetLossInfo) {
            try {
                return Float.parseFloat(packetLossInfo.replace("%", ""));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return -1;
    }

    /**
     * 获取ping url的丢包率
     *
     * @param url 需要ping的url地址
     * @return 丢包率 x%
     */
    public static String getPacketLoss(String url) {
        return getPacketLoss(url, DEFAULT_COUNT, TIME_OUT);
    }

    /**
     * 获取ping url的丢包率
     *
     * @param url     需要ping的url地址
     * @param count   需要ping的次数
     * @param timeout 需要ping的超时时间，单位ms
     * @return 丢包率 x%
     */
    public static String getPacketLoss(String url, int count, int timeout) {
        String domain = getDomain(url);
        if (null == domain) {
            return null;
        }
        String pingString = ping(createSimplePingCommand(count, timeout, domain));
        if (null != pingString) {
            try {
                String tempInfo = pingString.substring(pingString.indexOf("received,"));
                return tempInfo.substring(9, tempInfo.indexOf("packet"));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }


    // ********************以下是一些辅助方法，设为private********************//

    /**
     * 域名获取
     *
     * @param url 网址
     * @return
     */
    private static String getDomain(String url) {
        String domain = null;
        try {
            domain = URI.create(url).getHost();
            if (null == domain && isMatch(ipRegex,url)) {
                domain = url;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return domain;
    }

    private static boolean isMatch(String regex, String string) {
        return Pattern.matches(regex, string);
    }

    /**
     * ping方法，调用ping指令
     *
     * @param command ping指令文本
     * @return
     */
    private static String ping(String command) {
        Process process = null;
        try {
            process = Runtime.getRuntime().exec(command);       //执行ping指令
            InputStream is = process.getInputStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(is));
            StringBuilder sb = new StringBuilder();
            String line;
            while (null != (line = reader.readLine())) {
                sb.append(line);
                sb.append("\n");
            }
            reader.close();
            is.close();
            return sb.toString();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (null != process) {
                process.destroy();
            }
        }
        return null;
    }

    /**
     * ping指令格式文本
     *
     * @param count   调用次数
     * @param timeout 超时时间
     * @param domain  地址
     * @return
     */
    private static String createSimplePingCommand(int count, int timeout, String domain) {
        return "/system/bin/ping -c " + count + " -w " + timeout + " " + domain;
    }
}