应用发生crash之后要查看log，判断问题出在什么地方，可是一旦应用发布出去，就要想办法把用户的崩溃日志拿到分析。
所以要在发生crash之后抓取log，然后上传到服务器，方便开发者查看，现在都有很多第三方做这方面的服务，这里说下如何自己来实现。
其实原理很简单，应用出现异常后，会由默认的异常处理器来处理异常，
我们要做的就是把这个任务接管过来，自己处理异常，包括收集日志，保存到本地，然后上传到服务器。
下面是自己实现的异常处理类。
1. public class CrashHandler implements
2. public static final String TAG = “CrashHandler”;
3.
4. // 系统默认的UncaughtException处理类
5. private
6. // CrashHandler实例
7. private static CrashHandler INSTANCE = new
8. // 程序的Context对象
9. private
10. // 用来存储设备信息和异常信息
11. private Map<String, String> infos = new
12.
13. // 用于格式化日期,作为日志文件名的一部分
14. private DateFormat formatter = new SimpleDateFormat(“yyyy-MM-dd_HH-mm-ss”);
15. private
16.
17. /** 保证只有一个CrashHandler实例 */
18. private
19. }
20.
21. /** 获取CrashHandler实例 ,单例模式 */
22. public static
23. return
24. }
25.
26. /**
27. * 初始化
28. *
29. * @param context
30. */
31. public void
32. mContext = context;
33. // 获取系统默认的UncaughtException处理器
34. mDefaultHandler = Thread.getDefaultUncaughtExceptionHandler();
35. // 设置该CrashHandler为程序的默认处理器
36. this);
37. nameString = BmobUserManager.getInstance(mContext).getCurrentUserName();
38. }
39.
40. /**
41. * 当UncaughtException发生时会转入该函数来处理
42. */
43. @Override
44. public void
45. if (!handleException(ex) && mDefaultHandler != null) {
46. // 如果用户没有处理则让系统默认的异常处理器来处理
47. mDefaultHandler.uncaughtException(thread, ex);
48. else
49. try
50. 3000);
51. catch
52. ”error : ”, e);
53. }
54. // 退出程序
55. android.os.Process.killProcess(android.os.Process.myPid());
56. 1);
57. }
58. }
59.
60. /**
61. * 自定义错误处理,收集错误信息 发送错误报告等操作均在此完成.
62. *
63. * @param ex
64. * @return true:如果处理了该异常信息;否则返回false.
65. */
66. private boolean
67. if (ex == null) {
68. return false;
69. }
70. true);// 每次进入应用检查，是否有log，有则上传
71. // 使用Toast来显示异常信息
72. new
73. @Override
74. public void
75. Looper.prepare();
76. ”很抱歉,程序出现异常,正在收集日志，即将退出”, Toast.LENGTH_LONG)
77. .show();
78. Looper.loop();
79. }
80. }.start();
81. // 收集设备参数信息
82. collectDeviceInfo(mContext);
83. // 保存日志文件
84. String fileName = saveCrashInfo2File(ex);
85. return true;
86. }
87.
88. /**
89. * 收集设备参数信息
90. *
91. * @param ctx
92. */
93. public void
94. try
95. PackageManager pm = ctx.getPackageManager();
96. PackageInfo pi = pm.getPackageInfo(ctx.getPackageName(),
97. PackageManager.GET_ACTIVITIES);
98. if (pi != null) {
99. null ? “null”
100. : pi.versionName;
101. ”“;
102. ”versionName”, versionName);
103. ”versionCode”, versionCode);
104. }
105. catch
106. ”an error occured when collect package info”, e);
107. }
108. class.getDeclaredFields();
109. for
110. try
111. true);
112. null).toString());
113. ” : ” + field.get(null));
114. catch
115. ”an error occured when collect crash info”, e);
116. }
117. }
118. }
119.
120. /**
121. * 保存错误信息到文件中
122. *
123. * @param ex
124. * @return 返回文件名称,便于将文件传送到服务器
125. */
126. private
127.
128. new
129. for
130. String key = entry.getKey();
131. String value = entry.getValue();
132. ”=” + value + “\n”);
133. }
134.
135. new
136. new
137. ex.printStackTrace(printWriter);
138. Throwable cause = ex.getCause();
139. while (cause != null) {
140. cause.printStackTrace(printWriter);
141. cause = cause.getCause();
142. }
143. printWriter.close();
144. String result = writer.toString();
145. L.d(WModel.CrashUpload, result);
146. sb.append(result);
147. try
148. long
149. new
150. ”-“ + time + “-“
151. ”.log”;
152. if
153. Environment.MEDIA_MOUNTED)) {
154. String path = WMapConstants.CrashLogDir;
155. new
156. if
157. dir.mkdirs();
158. }
159. new
160. fos.write(sb.toString().getBytes());
161. fos.close();
162. }
163. return
164. catch
165. ”an error occured while writing file…”, e);
166. }
167. return null;
168. }
169.
170. }
使用方式如下：
在Application的onCreate中加上下面
CrashHandler crashHandler = CrashHandler.getInstance();
crashHandler.init(this);
这样一来，应用发生crash，自动保存log到本地了。
其实这样还有一个好处，就是不用在logcat里面翻来翻去找日志，直接到本地文件夹打开看就是了。另外还有一个问题,我严重怀疑umeng的错误统计就是这么搞的,他只是他那个东西发送给umen自己的服务器,展视到平台上罢了,不过说实话,umeng是比较好用的一个东西
应用发生crash之后要查看log，判断问题出在什么地方，可是一旦应用发布出去，就要想办法把用户的崩溃日志拿到分析。
所以要在发生crash之后抓取log，然后上传到服务器，方便开发者查看，现在都有很多第三方做这方面的服务，这里说下如何自己来实现。
其实原理很简单，应用出现异常后，会由默认的异常处理器来处理异常，
我们要做的就是把这个任务接管过来，自己处理异常，包括收集日志，保存到本地，然后上传到服务器。
下面是自己实现的异常处理类。
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");
private String nameString;
/** 保证只有一个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);
nameString = BmobUserManager.getInstance(mContext).getCurrentUserName();
}
/**
* 当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(Throwable ex) {
if (ex == null) {
return false;
}
WonderMapApplication.getInstance().getSpUtil().setCrashLog(true);// 每次进入应用检查，是否有log，有则上传
// 使用Toast来显示异常信息
new Thread() {
@Override
public void run() {
Looper.prepare();
Toast.makeText(mContext, "很抱歉,程序出现异常,正在收集日志，即将退出", Toast.LENGTH_LONG)
.show();
Looper.loop();
}
}.start();
// 收集设备参数信息
collectDeviceInfo(mContext);
// 保存日志文件
String fileName = 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();
L.d(WModel.CrashUpload, result);
sb.append(result);
try {
long timestamp = System.currentTimeMillis();
String time = formatter.format(new Date());
String fileName = nameString + "-" + time + "-" + timestamp
+ ".log";
if (Environment.getExternalStorageState().equals(
Environment.MEDIA_MOUNTED)) {
String path = WMapConstants.CrashLogDir;
File dir = new File(path);
if (!dir.exists()) {
dir.mkdirs();
}
FileOutputStream fos = new FileOutputStream(path + fileName);
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的onCreate中加上下面
CrashHandler crashHandler = CrashHandler.getInstance();
crashHandler.init(this);
这样一来，应用发生crash，自动保存log到本地了。
其实这样还有一个好处，就是不用在logcat里面翻来翻去找日志，直接到本地文件夹打开看就是了。另外还有一个问题,我严重怀疑umeng的错误统计就是这么搞的,他只是他那个东西发送给umen自己的服务器,展视到平台上罢了,不过说实话,umeng是比较好用的一个东西
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
