Android中调用Ping操作及结果分析_ping -c 1

作者：秋刀鱼在做梦 | 2024-08-05 20:45:03

踩

ping -c 1

实现方法

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指令
1

结果解析

调用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
1
2
3
4
5
6

可以从其中看到本次结果的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;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

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

    /**
     * 获取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;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

工具类完整代码

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】