android app记录运行日志捕获奔溃异常，存储日志到文件

118 阅读 0 评论 78 点赞

我是靠谱客的博主真实机器猫，这篇文章主要介绍android app记录运行日志捕获奔溃异常，存储日志到文件，现在分享给大家，希望可以做个参考。

感恩原创：http://blog.csdn.net/u014763302/article/details/47422023

app在运行过程中，为了后期的维护升级，记录日志是一个非常好的方法。

为了读取到app运行时的日志，一般的作法是单独开一个线程，在app运行的启动线程，然后app退出时停掉线程。

然而我们更好的方法是开启一个service，然后在里面做日志记录，代码如下：

复制代码

package com.hai.logcat;
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.List;
import android.app.ActivityManager;
import android.app.ActivityManager.RunningAppProcessInfo;
import android.app.Service;
import android.content.Intent;
import android.os.Environment;
import android.os.IBinder;
import android.os.Looper;
import android.util.Log;
import android.widget.Toast;
public class MyLogcat extends Service {
Thread thread;
boolean readlog = true;
@Override
public IBinder onBind(Intent intent) {
return null;
}
@Override
public void onCreate() {
super.onCreate();
Log.d("hhp", "onCreate");
thread = new Thread(new Runnable() {
@Override
public void run() {
log2();//个人觉得这个方法更实用
}
});
}
@Override
public void onStart(Intent intent, int startId) {
thread.start();
Log.d("hhp", "onStart");
super.onStart(intent, startId);
}
/**
* 方法1
*/
private void log2() {
Log.d("hhp", "log2 start");
String[] cmds = { "logcat", "-c" };
String shellCmd = "logcat -v time -s *:W "; // adb logcat -v time *:W
Process process = null;
Runtime runtime = Runtime.getRuntime();
BufferedReader reader = null;
try {
runtime.exec(cmds).waitFor();
process = runtime.exec(shellCmd);
reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
String line = null;
while ((line = reader.readLine()) != null) {
if (line.contains(String.valueOf(android.os.Process.myPid()))) {
// line = new String(line.getBytes("iso-8859-1"), "utf-8");
writeTofile(line);
}
}
} catch (Exception e) {
e.printStackTrace();
}
Log.d("hhp", "log2 finished");
}
/**
* 方法2
*/
private void log() {
Log.d("hhp", "log start");
String[] cmds = { "logcat", "-c" };
String shellCmd = "logcat -v time -s *:W ";// //adb logcat -v time *:W
Process process = null;
InputStream is = null;
DataInputStream dis = null;
String line = "";
Runtime runtime = Runtime.getRuntime();
try {
runtime.exec(cmds);
process = runtime.exec(shellCmd);
is = process.getInputStream();
dis = new DataInputStream(is);
// String filter = GetPid();
String filter = android.os.Process.myPid() + "";
while ((line = dis.readLine()) != null) { //这里如果输入流没断，会一直循环下去。
line = new String(line.getBytes("iso-8859-1"), "utf-8");
if (line.contains(filter)) {
int pos = line.indexOf(":");
Log.d("hhp2", line + "");
writeTofile(line);
}
}
} catch (Exception e) {
}
Log.d("hhp", "log finished");
}
private void writeTofile(String line) {
String content = line + "rn";
File file = new File(Environment.getExternalStorageDirectory().getAbsolutePath()
+ "/logcat/myLog.txt");
if (!file.exists()) {
try {
file.createNewFile();
} catch (Exception e) {
e.printStackTrace();
}
}
FileOutputStream fos;
try {
fos = new FileOutputStream(file, true);
fos.write(content.getBytes());
fos.flush();
fos.close();
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void onDestroy() {
super.onDestroy();
stopSelf();
}
}

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
package com.hai.logcat;
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.List;
import android.app.ActivityManager;
import android.app.ActivityManager.RunningAppProcessInfo;
import android.app.Service;
import android.content.Intent;
import android.os.Environment;
import android.os.IBinder;
import android.os.Looper;
import android.util.Log;
import android.widget.Toast;
public class MyLogcat extends Service {
Thread thread;
boolean readlog = true;
@Override
public IBinder onBind(Intent intent) {
return null;
}
@Override
public void onCreate() {
super.onCreate();
Log.d("hhp", "onCreate");
thread = new Thread(new Runnable() {
@Override
public void run() {
log2();//个人觉得这个方法更实用
}
});
}
@Override
public void onStart(Intent intent, int startId) {
thread.start();
Log.d("hhp", "onStart");
super.onStart(intent, startId);
}
/**
* 方法1
*/
private void log2() {
Log.d("hhp", "log2 start");
String[] cmds = { "logcat", "-c" };
String shellCmd = "logcat -v time -s *:W "; // adb logcat -v time *:W
Process process = null;
Runtime runtime = Runtime.getRuntime();
BufferedReader reader = null;
try {
runtime.exec(cmds).waitFor();
process = runtime.exec(shellCmd);
reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
String line = null;
while ((line = reader.readLine()) != null) {
if (line.contains(String.valueOf(android.os.Process.myPid()))) {
// line = new String(line.getBytes("iso-8859-1"), "utf-8");
writeTofile(line);
}
}
} catch (Exception e) {
e.printStackTrace();
}
Log.d("hhp", "log2 finished");
}
/**
* 方法2
*/
private void log() {
Log.d("hhp", "log start");
String[] cmds = { "logcat", "-c" };
String shellCmd = "logcat -v time -s *:W ";// //adb logcat -v time *:W
Process process = null;
InputStream is = null;
DataInputStream dis = null;
String line = "";
Runtime runtime = Runtime.getRuntime();
try {
runtime.exec(cmds);
process = runtime.exec(shellCmd);
is = process.getInputStream();
dis = new DataInputStream(is);
// String filter = GetPid();
String filter = android.os.Process.myPid() + "";
while ((line = dis.readLine()) != null) { //这里如果输入流没断，会一直循环下去。
line = new String(line.getBytes("iso-8859-1"), "utf-8");
if (line.contains(filter)) {
int pos = line.indexOf(":");
Log.d("hhp2", line + "");
writeTofile(line);
}
}
} catch (Exception e) {
}
Log.d("hhp", "log finished");
}
private void writeTofile(String line) {
String content = line + "rn";
File file = new File(Environment.getExternalStorageDirectory().getAbsolutePath()
+ "/logcat/myLog.txt");
if (!file.exists()) {
try {
file.createNewFile();
} catch (Exception e) {
e.printStackTrace();
}
}
FileOutputStream fos;
try {
fos = new FileOutputStream(file, true);
fos.write(content.getBytes());
fos.flush();
fos.close();
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void onDestroy() {
super.onDestroy();
stopSelf();
}
}

代码比较简单，所以没怎么注视了。说下大概思路：在service开启的时候，就开启线程不停地从logcat中读取输入流，

把读到的信息存入文件中，service停止的时候线程stop，就这么简单。

当然要读入系统日志还需要添加权限：

这里写图片描述

上面的代码基本可以记录本app运行中的日志，但如果中途有未捕获的异常导致app奔溃，那么这个未捕获的异常导致的奔溃上面代码就记录不到了。

因为这个异常导致app奔溃，虚拟机挂掉，那当然记录日志的线程也停了。那怎么捕获这类我们未捕获的异常（运行时异常）呢，幸好android这样

一个接口UncaughtExceptionHandler，当app奔溃前，它会先通知这个接口，这样我们就可以在app奔溃前做点自己想做的事了。

关于怎么捕获奔溃异常，我觉得这位哥们的一片博客写的不错http://blog.csdn.net/liuhe688/article/details/6584143#，我借鉴着改了下：

复制代码

package com.hai.logcat;
import java.io.File;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.Writer;
import java.lang.Thread.UncaughtExceptionHandler;
import java.lang.reflect.Field;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import android.content.Context;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;
import android.os.Build;
import android.os.Environment;
import android.os.Looper;
import android.util.Log;
import android.widget.Toast;
public class CrashHandler implements UncaughtExceptionHandler {
public static final String TAG = "CrashHandler";
// 系统默认的UncaughtException处理类
private Thread.UncaughtExceptionHandler mDefaultHandler;
// CrashHandler实例
private static CrashHandler INSTANCE = new CrashHandler();
// 程序的Context对象
private Context mContext;
// 用来存储设备信息和异常信息
private Map<String, String> infos = new HashMap<String, String>();
// 用于格式化日期,作为日志文件名的一部分
private DateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss
");
/** 保证只有一个CrashHandler实例 */
private CrashHandler() {
}
/** 获取CrashHandler实例 ,单例模式 */
public static CrashHandler getInstance() {
return INSTANCE;
}
/**
* 初始化
*
* @param context
*/
public void init(Context context) {
mContext = context;
// 获取系统默认的UncaughtException处理器
mDefaultHandler = Thread.getDefaultUncaughtExceptionHandler();
// 设置该CrashHandler为程序的默认处理器
Thread.setDefaultUncaughtExceptionHandler(this);
}
/**
* 当UncaughtException发生时会转入该函数来处理
*/
@Override
public void uncaughtException(Thread thread, Throwable ex) {
if (!handleException(ex) && mDefaultHandler != null) {
// 如果用户没有处理则让系统默认的异常处理器来处理
mDefaultHandler.uncaughtException(thread, ex);
} else {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
Log.e(TAG, "error : ", e);
}
// 退出程序
android.os.Process.killProcess(android.os.Process.myPid());
System.exit(1);
}
}
/**
* 自定义错误处理,收集错误信息 发送错误报告等操作均在此完成.
*
* @param ex
* @return true:如果处理了该异常信息;否则返回false.
*/
private boolean handleException(final Throwable ex) {
if (ex == null) {
return false;
}
// 使用Toast来显示异常信息
new Thread() {
@Override
public void run() {
Looper.prepare();
ex.printStackTrace();
Toast.makeText(mContext, "很抱歉,程序出现异常,即将退出.", Toast.LENGTH_LONG).show();
Looper.loop();
}
}.start();
// 收集设备参数信息
collectDeviceInfo(mContext);
// 保存日志文件
saveCrashInfo2File(ex);
return true;
}
/**
* 收集设备参数信息
*
* @param ctx
*/
public void collectDeviceInfo(Context ctx) {
try {
PackageManager pm = ctx.getPackageManager();
PackageInfo pi = pm.getPackageInfo(ctx.getPackageName(), PackageManager.GET_ACTIVITIES);
if (pi != null) {
String versionName = pi.versionName == null ? "null" : pi.versionName;
String versionCode = pi.versionCode + "";
infos.put("versionName", versionName);
infos.put("versionCode", versionCode);
}
} catch (NameNotFoundException e) {
Log.e(TAG, "an error occured when collect package info", e);
}
Field[] fields = Build.class.getDeclaredFields();
for (Field field : fields) {
try {
field.setAccessible(true);
infos.put(field.getName(), field.get(null).toString());
Log.d(TAG, field.getName() + " : " + field.get(null));
} catch (Exception e) {
Log.e(TAG, "an error occured when collect crash info", e);
}
}
}
/**
* 保存错误信息到文件中
*
* @param ex
* @return 返回文件名称,便于将文件传送到服务器
*/
private String saveCrashInfo2File(Throwable ex) {
StringBuffer sb = new StringBuffer();
for (Map.Entry<String, String> entry : infos.entrySet()) {
String key = entry.getKey();
String value = entry.getValue();
sb.append(key + "=" + value + "n");
}
Writer writer = new StringWriter();
PrintWriter printWriter = new PrintWriter(writer);
ex.printStackTrace(printWriter);
Throwable cause = ex.getCause();
while (cause != null) {
cause.printStackTrace(printWriter);
cause = cause.getCause();
}
printWriter.close();
String result = writer.toString();
String time = formatter.format(new Date());
sb.append(time + result);
try {
long timestamp = System.currentTimeMillis();
String fileName = "crash.log";
if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
String path =Environment.getExternalStorageDirectory().getAbsolutePath()+ "/logcat/";
File dir = new File(path);
if (!dir.exists()) {
dir.mkdirs();
}
FileOutputStream fos = new FileOutputStream(path + fileName, true);
fos.write((sb.toString()).getBytes());
fos.close();
}
return fileName;
} catch (Exception e) {
Log.e(TAG, "an error occured while writing file...", e);
}
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
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
package com.hai.logcat;
import java.io.File;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.Writer;
import java.lang.Thread.UncaughtExceptionHandler;
import java.lang.reflect.Field;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import android.content.Context;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;
import android.os.Build;
import android.os.Environment;
import android.os.Looper;
import android.util.Log;
import android.widget.Toast;
public class CrashHandler implements UncaughtExceptionHandler {
public static final String TAG = "CrashHandler";
// 系统默认的UncaughtException处理类
private Thread.UncaughtExceptionHandler mDefaultHandler;
// CrashHandler实例
private static CrashHandler INSTANCE = new CrashHandler();
// 程序的Context对象
private Context mContext;
// 用来存储设备信息和异常信息
private Map<String, String> infos = new HashMap<String, String>();
// 用于格式化日期,作为日志文件名的一部分
private DateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss
");
/** 保证只有一个CrashHandler实例 */
private CrashHandler() {
}
/** 获取CrashHandler实例 ,单例模式 */
public static CrashHandler getInstance() {
return INSTANCE;
}
/**
* 初始化
*
* @param context
*/
public void init(Context context) {
mContext = context;
// 获取系统默认的UncaughtException处理器
mDefaultHandler = Thread.getDefaultUncaughtExceptionHandler();
// 设置该CrashHandler为程序的默认处理器
Thread.setDefaultUncaughtExceptionHandler(this);
}
/**
* 当UncaughtException发生时会转入该函数来处理
*/
@Override
public void uncaughtException(Thread thread, Throwable ex) {
if (!handleException(ex) && mDefaultHandler != null) {
// 如果用户没有处理则让系统默认的异常处理器来处理
mDefaultHandler.uncaughtException(thread, ex);
} else {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
Log.e(TAG, "error : ", e);
}
// 退出程序
android.os.Process.killProcess(android.os.Process.myPid());
System.exit(1);
}
}
/**
* 自定义错误处理,收集错误信息 发送错误报告等操作均在此完成.
*
* @param ex
* @return true:如果处理了该异常信息;否则返回false.
*/
private boolean handleException(final Throwable ex) {
if (ex == null) {
return false;
}
// 使用Toast来显示异常信息
new Thread() {
@Override
public void run() {
Looper.prepare();
ex.printStackTrace();
Toast.makeText(mContext, "很抱歉,程序出现异常,即将退出.", Toast.LENGTH_LONG).show();
Looper.loop();
}
}.start();
// 收集设备参数信息
collectDeviceInfo(mContext);
// 保存日志文件
saveCrashInfo2File(ex);
return true;
}
/**
* 收集设备参数信息
*
* @param ctx
*/
public void collectDeviceInfo(Context ctx) {
try {
PackageManager pm = ctx.getPackageManager();
PackageInfo pi = pm.getPackageInfo(ctx.getPackageName(), PackageManager.GET_ACTIVITIES);
if (pi != null) {
String versionName = pi.versionName == null ? "null" : pi.versionName;
String versionCode = pi.versionCode + "";
infos.put("versionName", versionName);
infos.put("versionCode", versionCode);
}
} catch (NameNotFoundException e) {
Log.e(TAG, "an error occured when collect package info", e);
}
Field[] fields = Build.class.getDeclaredFields();
for (Field field : fields) {
try {
field.setAccessible(true);
infos.put(field.getName(), field.get(null).toString());
Log.d(TAG, field.getName() + " : " + field.get(null));
} catch (Exception e) {
Log.e(TAG, "an error occured when collect crash info", e);
}
}
}
/**
* 保存错误信息到文件中
*
* @param ex
* @return 返回文件名称,便于将文件传送到服务器
*/
private String saveCrashInfo2File(Throwable ex) {
StringBuffer sb = new StringBuffer();
for (Map.Entry<String, String> entry : infos.entrySet()) {
String key = entry.getKey();
String value = entry.getValue();
sb.append(key + "=" + value + "n");
}
Writer writer = new StringWriter();
PrintWriter printWriter = new PrintWriter(writer);
ex.printStackTrace(printWriter);
Throwable cause = ex.getCause();
while (cause != null) {
cause.printStackTrace(printWriter);
cause = cause.getCause();
}
printWriter.close();
String result = writer.toString();
String time = formatter.format(new Date());
sb.append(time + result);
try {
long timestamp = System.currentTimeMillis();
String fileName = "crash.log";
if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
String path =Environment.getExternalStorageDirectory().getAbsolutePath()+ "/logcat/";
File dir = new File(path);
if (!dir.exists()) {
dir.mkdirs();
}
FileOutputStream fos = new FileOutputStream(path + fileName, true);
fos.write((sb.toString()).getBytes());
fos.close();
}
return fileName;
} catch (Exception e) {
Log.e(TAG, "an error occured while writing file...", e);
}
return null;
}
}

上面我们实现了这个接口，然后在奔溃前做了一些友好处理，如存储奔溃日志，主动杀死进程，不让弹出系统的强制关闭对话框。

然后我们在Application中这样引用即可

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
package com.hai;
import android.app.Application;
import com.hai.logcat.CrashHandler;
public class MyApplication extends Application {
CrashHandler handler = null;
@Override
public void onCreate() {
super.onCreate();
handler = CrashHandler.getInstance();
handler.init(getApplicationContext());
}
}