Android将程序崩溃信息保存本地文件

大家都知道，现在安装Android系统的手机版本和设备千差万别，在模拟器上运行良好的程序安装到某款手机上说不定就出现崩溃的现象，开发者个人不可能购买所有设备逐个调试，所以在程序发布出去之后，如果出现了崩溃现象，开发者应该及时获取在该设备上导致崩溃的信息，这对于下一个版本的bug修复帮助极大，所以今天就来介绍一下如何在程序崩溃的情况下收集相关的设备参数信息和具体的异常信息，并发送这些信息到服务器供开发者分析和调试程序。

源码下载地址：http://download.csdn.net/detail/weidi1989/4588310

我们先建立一个crash项目，项目结构如图：

在MainActivity.java代码中，故意制作一个错误的例子，以便于我们实验：

[java]view plaincopy

1. packagecom.scott.crash;
3. importandroid.app.Activity;
4. importandroid.os.Bundle;
6. publicclassMainActivityextendsActivity{
8. privateStrings;
10. @Override
11. publicvoidonCreate(BundlesavedInstanceState){
12. super.onCreate(savedInstanceState);
13. System.out.println(s.equals("anystring"));
14. }
15. }

我们在这里故意制造了一个潜在的运行期异常，当我们运行程序时就会出现以下界面：

遇到软件没有捕获的异常之后，系统会弹出这个默认的强制关闭对话框。

我们当然不希望用户看到这种现象，简直是对用户心灵上的打击，而且对我们的bug的修复也是毫无帮助的。我们需要的是软件有一个全局的异常捕获器，当出现一个我们没有发现的异常时，捕获这个异常，并且将异常信息记录下来，上传到服务器公开发这分析出现异常的具体原因。

接下来我们就来实现这一机制，不过首先我们还是来了解以下两个类：android.app.Application和java.lang.Thread.UncaughtExceptionHandler。

Application：用来管理应用程序的全局状态。在应用程序启动时Application会首先创建，然后才会根据情况(Intent)来启动相应的Activity和Service。本示例中将在自定义加强版的Application中注册未捕获异常处理器。

Thread.UncaughtExceptionHandler：线程未捕获异常处理器，用来处理未捕获异常。如果程序出现了未捕获异常，默认会弹出系统中强制关闭对话框。我们需要实现此接口，并注册为程序中默认未捕获异常处理。这样当未捕获异常发生时，就可以做一些个性化的异常处理操作。

大家刚才在项目的结构图中看到的CrashHandler.java实现了Thread.UncaughtExceptionHandler，使我们用来处理未捕获异常的主要成员，代码如下：

[java]view plaincopy

1. packagecom.way.crash;
3. importjava.io.File;
4. importjava.io.FileNotFoundException;
5. importjava.io.FileOutputStream;
6. importjava.io.IOException;
7. importjava.io.PrintWriter;
8. importjava.io.StringWriter;
9. importjava.io.Writer;
10. importjava.lang.Thread.UncaughtExceptionHandler;
11. importjava.lang.reflect.Field;
12. importjava.text.SimpleDateFormat;
13. importjava.util.Date;
14. importjava.util.HashMap;
15. importjava.util.Map;
17. importandroid.content.Context;
18. importandroid.content.pm.PackageInfo;
19. importandroid.content.pm.PackageManager;
20. importandroid.content.pm.PackageManager.NameNotFoundException;
21. importandroid.os.Build;
22. importandroid.os.Environment;
23. importandroid.os.Looper;
24. importandroid.util.Log;
25. importandroid.widget.Toast;
27. /**
28. *UncaughtException处理类,当程序发生Uncaught异常的时候,由该类来接管程序,并记录发送错误报告.
29. *
30. *@authorway
31. *
32. */
33. publicclassCrashHandlerimplementsUncaughtExceptionHandler{
34. privatestaticfinalStringTAG="CrashHandler";
35. privateThread.UncaughtExceptionHandlermDefaultHandler;//系统默认的UncaughtException处理类
36. privatestaticCrashHandlerINSTANCE=newCrashHandler();//CrashHandler实例
37. privateContextmContext;//程序的Context对象
38. privateMap<String,String>info=newHashMap<String,String>();//用来存储设备信息和异常信息
39. privateSimpleDateFormatformat=newSimpleDateFormat(
40. "yyyy-MM-dd-HH-mm-ss");//用于格式化日期,作为日志文件名的一部分
42. /**保证只有一个CrashHandler实例*/
43. privateCrashHandler(){
45. }
47. /**获取CrashHandler实例,单例模式*/
48. publicstaticCrashHandlergetInstance(){
49. returnINSTANCE;
50. }
52. /**
53. *初始化
54. *
55. *@paramcontext
56. */
57. publicvoidinit(Contextcontext){
58. mContext=context;
59. mDefaultHandler=Thread.getDefaultUncaughtExceptionHandler();//获取系统默认的UncaughtException处理器
60. Thread.setDefaultUncaughtExceptionHandler(this);//设置该CrashHandler为程序的默认处理器
61. }
63. /**
64. *当UncaughtException发生时会转入该重写的方法来处理
65. */
66. publicvoiduncaughtException(Threadthread,Throwableex){
67. if(!handleException(ex)&&mDefaultHandler!=null){
68. //如果自定义的没有处理则让系统默认的异常处理器来处理
69. mDefaultHandler.uncaughtException(thread,ex);
70. }else{
71. try{
72. Thread.sleep(3000);//如果处理了，让程序继续运行3秒再退出，保证文件保存并上传到服务器
73. }catch(InterruptedExceptione){
74. e.printStackTrace();
75. }
76. //退出程序
77. android.os.Process.killProcess(android.os.Process.myPid());
78. System.exit(1);
79. }
80. }
82. /**
83. *自定义错误处理,收集错误信息发送错误报告等操作均在此完成.
84. *
85. *@paramex
86. *异常信息
87. *@returntrue如果处理了该异常信息;否则返回false.
88. */
89. publicbooleanhandleException(Throwableex){
90. if(ex==null)
91. returnfalse;
92. newThread(){
93. publicvoidrun(){
94. Looper.prepare();
95. Toast.makeText(mContext,"很抱歉,程序出现异常,即将退出",0).show();
96. Looper.loop();
97. }
98. }.start();
99. //收集设备参数信息
100. collectDeviceInfo(mContext);
101. //保存日志文件
102. saveCrashInfo2File(ex);
103. returntrue;
104. }
106. /**
107. *收集设备参数信息
108. *
109. *@paramcontext
110. */
111. publicvoidcollectDeviceInfo(Contextcontext){
112. try{
113. PackageManagerpm=context.getPackageManager();//获得包管理器
114. PackageInfopi=pm.getPackageInfo(context.getPackageName(),
115. PackageManager.GET_ACTIVITIES);//得到该应用的信息，即主Activity
116. if(pi!=null){
117. StringversionName=pi.versionName==null?"null"
118. :pi.versionName;
119. StringversionCode=pi.versionCode+"";
120. info.put("versionName",versionName);
121. info.put("versionCode",versionCode);
122. }
123. }catch(NameNotFoundExceptione){
124. e.printStackTrace();
125. }
127. Field[]fields=Build.class.getDeclaredFields();//反射机制
128. for(Fieldfield:fields){
129. try{
130. field.setAccessible(true);
131. info.put(field.getName(),field.get("").toString());
132. Log.d(TAG,field.getName()+":"+field.get(""));
133. }catch(IllegalArgumentExceptione){
134. e.printStackTrace();
135. }catch(IllegalAccessExceptione){
136. e.printStackTrace();
137. }
138. }
139. }
141. privateStringsaveCrashInfo2File(Throwableex){
142. StringBuffersb=newStringBuffer();
143. for(Map.Entry<String,String>entry:info.entrySet()){
144. Stringkey=entry.getKey();
145. Stringvalue=entry.getValue();
146. sb.append(key+"="+value+"\r\n");
147. }
148. Writerwriter=newStringWriter();
149. PrintWriterpw=newPrintWriter(writer);
150. ex.printStackTrace(pw);
151. Throwablecause=ex.getCause();
152. //循环着把所有的异常信息写入writer中
153. while(cause!=null){
154. cause.printStackTrace(pw);
155. cause=cause.getCause();
156. }
157. pw.close();//记得关闭
158. Stringresult=writer.toString();
159. sb.append(result);
160. //保存文件
161. longtimetamp=System.currentTimeMillis();
162. Stringtime=format.format(newDate());
163. StringfileName="crash-"+time+"-"+timetamp+".log";
164. if(Environment.getExternalStorageState().equals(
165. Environment.MEDIA_MOUNTED)){
166. try{
167. Filedir=newFile(Environment.getExternalStorageDirectory().getAbsolutePath()+File.separator+"crash");
168. Log.i("CrashHandler",dir.toString());
169. if(!dir.exists())
170. dir.mkdir();
171. FileOutputStreamfos=newFileOutputStream(newFile(dir,
172. fileName));
173. fos.write(sb.toString().getBytes());
174. fos.close();
175. returnfileName;
176. }catch(FileNotFoundExceptione){
177. e.printStackTrace();
178. }catch(IOExceptione){
179. e.printStackTrace();
180. }
181. }
182. returnnull;
183. }
184. }

然后，我们需要在应用启动的时候在Application中注册一下：

[java]view plaincopy

1. packagecom.way.crash;
3. importandroid.app.Application;
5. publicclassCrashApplicationextendsApplication{
6. @Override
7. publicvoidonCreate(){
8. super.onCreate();
9. CrashHandlercrashHandler=CrashHandler.getInstance();
10. crashHandler.init(this);
11. }
12. }

最后，为了让我们的CrashApplication取代android.app.Application的地位，在我们的代码中生效，我们需要修改AndroidManifest.xml：

[html]view plaincopy

1. <applicationandroid:name=".CrashApplication"
2. android:icon="@drawable/ic_launcher"
3. android:label="@string/app_name"
4. android:theme="@style/AppTheme">
5. ...
6. </application>

因为我们上面的CrashHandler中，遇到异常后要保存设备参数和具体异常信息到SDCARD，所以我们需要在AndroidManifest.xml中加入读写SDCARD权限：

[html]view plaincopy

1. <uses-permissionandroid:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

搞定了上边的步骤之后，我们来运行一下这个项目：

可以看到，并不会有强制关闭的对话框出现了，取而代之的是我们比较有好的提示信息。

然后看一下SDCARD生成的文件：

用文本编辑器打开日志文件，看一段日志信息：

[plain]view plaincopy

1. CPU_ABI=armeabi
2. CPU_ABI2=unknown
3. ID=FRF91
4. MANUFACTURER=unknown
5. BRAND=generic
6. TYPE=eng
7. ......
8. Causedby:java.lang.NullPointerException
9. atcom.scott.crash.MainActivity.onCreate(MainActivity.java:13)
10. atandroid.app.Instrumentation.callActivityOnCreate(Instrumentation.java:1047)
11. atandroid.app.ActivityThread.performLaunchActivity(ActivityThread.java:2627)
12. ...11more

这些信息对于开发者来说帮助极大，所以我们需要将此日志文件上传到服务器。

下面是一个以邮件形式提交错误报告的方法(2013年06月06日新增)：

由于context为非Activity的context，所以，我把弹出的对话框用了系统windows属性，记得加上以下权限：

[html]view plaincopy

1. <uses-permissionandroid:name="android.permission.SYSTEM_ALERT_WINDOW"/>

[java]view plaincopy

1. /**
2. *UncaughtException处理类,当程序发生Uncaught异常的时候,由该类来接管程序,并记录发送错误报告.
3. *
4. *@authorway
5. *
6. */
7. publicclassCrashHandlerimplementsUncaughtExceptionHandler{
8. privateThread.UncaughtExceptionHandlermDefaultHandler;//系统默认的UncaughtException处理类
9. privatestaticCrashHandlerINSTANCE;//CrashHandler实例
10. privateContextmContext;//程序的Context对象
12. /**保证只有一个CrashHandler实例*/
13. privateCrashHandler(){
15. }
17. /**获取CrashHandler实例,单例模式*/
18. publicstaticCrashHandlergetInstance(){
19. if(INSTANCE==null)
20. INSTANCE=newCrashHandler();
21. returnINSTANCE;
22. }
24. /**
25. *初始化
26. *
27. *@paramcontext
28. */
29. publicvoidinit(Contextcontext){
30. mContext=context;
32. mDefaultHandler=Thread.getDefaultUncaughtExceptionHandler();//获取系统默认的UncaughtException处理器
33. Thread.setDefaultUncaughtExceptionHandler(this);//设置该CrashHandler为程序的默认处理器
34. }
36. /**
37. *当UncaughtException发生时会转入该重写的方法来处理
38. */
39. publicvoiduncaughtException(Threadthread,Throwableex){
40. if(!handleException(ex)&&mDefaultHandler!=null){
41. //如果自定义的没有处理则让系统默认的异常处理器来处理
42. mDefaultHandler.uncaughtException(thread,ex);
43. }
44. }
46. /**
47. *自定义错误处理,收集错误信息发送错误报告等操作均在此完成.
48. *
49. *@paramex
50. *异常信息
51. *@returntrue如果处理了该异常信息;否则返回false.
52. */
53. publicbooleanhandleException(Throwableex){
54. if(ex==null||mContext==null)
55. returnfalse;
56. finalStringcrashReport=getCrashReport(mContext,ex);
57. Log.i("error",crashReport);
58. newThread(){
59. publicvoidrun(){
60. Looper.prepare();
61. Filefile=save2File(crashReport);
62. sendAppCrashReport(mContext,crashReport,file);
63. Looper.loop();
64. }
66. }.start();
67. returntrue;
68. }
70. privateFilesave2File(StringcrashReport){
71. //TODOAuto-generatedmethodstub
72. StringfileName="crash-"+System.currentTimeMillis()+".txt";
73. if(Environment.getExternalStorageState().equals(
74. Environment.MEDIA_MOUNTED)){
75. try{
76. Filedir=newFile(Environment.getExternalStorageDirectory()
77. .getAbsolutePath()+File.separator+"crash");
78. if(!dir.exists())
79. dir.mkdir();
80. Filefile=newFile(dir,fileName);
81. FileOutputStreamfos=newFileOutputStream(file);
82. fos.write(crashReport.toString().getBytes());
83. fos.close();
84. returnfile;
85. }catch(FileNotFoundExceptione){
86. e.printStackTrace();
87. }catch(IOExceptione){
88. e.printStackTrace();
89. }
90. }
91. returnnull;
92. }
94. privatevoidsendAppCrashReport(finalContextcontext,
95. finalStringcrashReport,finalFilefile){
96. //TODOAuto-generatedmethodstub
97. AlertDialogmDialog=null;
98. AlertDialog.Builderbuilder=newAlertDialog.Builder(context);
99. builder.setIcon(android.R.drawable.ic_dialog_info);
100. builder.setTitle("程序出错啦");
101. builder.setMessage("请把错误报告以邮件的形式提交给我们，谢谢！");
102. builder.setPositiveButton(android.R.string.ok,
103. newDialogInterface.OnClickListener(){
104. publicvoidonClick(DialogInterfacedialog,intwhich){
106. //发送异常报告
107. try{
108. //注释部分是已文字内容形式发送错误信息
109. //Intentintent=newIntent(Intent.ACTION_SENDTO);
110. //intent.setType("text/plain");
111. //intent.putExtra(Intent.EXTRA_SUBJECT,
112. //"推聊Android客户端-错误报告");
113. //intent.putExtra(Intent.EXTRA_TEXT,crashReport);
114. //intent.setData(Uri
115. //.parse("mailto:way.ping.li@gmail.com"));
116. //intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
117. //context.startActivity(intent);
119. //下面是以附件形式发送邮件
120. Intentintent=newIntent(Intent.ACTION_SEND);
121. intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
122. String[]tos={"way.ping.li@gmail.com"};
123. intent.putExtra(Intent.EXTRA_EMAIL,tos);
125. intent.putExtra(Intent.EXTRA_SUBJECT,
126. "推聊Android客户端-错误报告");
127. if(file!=null){
128. intent.putExtra(Intent.EXTRA_STREAM,
129. Uri.fromFile(file));
130. intent.putExtra(Intent.EXTRA_TEXT,
131. "请将此错误报告发送给我，以便我尽快修复此问题，谢谢合作！\n");
132. }else{
133. intent.putExtra(Intent.EXTRA_TEXT,
134. "请将此错误报告发送给我，以便我尽快修复此问题，谢谢合作！\n"
135. +crashReport);
136. }
137. intent.setType("text/plain");
138. intent.setType("message/rfc882");
139. Intent.createChooser(intent,"ChooseEmailClient");
140. context.startActivity(intent);
141. }catch(Exceptione){
142. Toast.makeText(context,
143. "Therearenoemailclientsinstalled.",
144. Toast.LENGTH_SHORT).show();
145. }finally{
146. dialog.dismiss();
147. //退出
148. android.os.Process.killProcess(android.os.Process
149. .myPid());
150. System.exit(1);
151. }
152. }
153. });
154. builder.setNegativeButton(android.R.string.cancel,
155. newDialogInterface.OnClickListener(){
156. publicvoidonClick(DialogInterfacedialog,intwhich){
157. dialog.dismiss();
158. //退出
159. android.os.Process.killProcess(android.os.Process
160. .myPid());
161. System.exit(1);
162. }
163. });
164. mDialog=builder.create();
165. mDialog.getWindow().setType(
166. WindowManager.LayoutParams.TYPE_SYSTEM_ALERT);
167. mDialog.show();
168. }
170. /**
171. *获取APP崩溃异常报告
172. *
173. *@paramex
174. *@return
175. */
176. privateStringgetCrashReport(Contextcontext,Throwableex){
177. PackageInfopinfo=getPackageInfo(context);
178. StringBufferexceptionStr=newStringBuffer();
179. exceptionStr.append("Version:"+pinfo.versionName+"("
180. +pinfo.versionCode+")\n");
181. exceptionStr.append("Android:"+android.os.Build.VERSION.RELEASE
182. +"("+android.os.Build.MODEL+")\n");
183. exceptionStr.append("Exception:"+ex.getMessage()+"\n");
184. StackTraceElement[]elements=ex.getStackTrace();
185. for(inti=0;i<elements.length;i++){
186. exceptionStr.append(elements[i].toString()+"\n");
187. }
188. returnexceptionStr.toString();
189. }
191. /**
192. *获取App安装包信息
193. *
194. *@return
195. */
196. privatePackageInfogetPackageInfo(Contextcontext){
197. PackageInfoinfo=null;
198. try{
199. info=context.getPackageManager().getPackageInfo(
200. context.getPackageName(),0);
201. }catch(NameNotFoundExceptione){
202. //e.printStackTrace(System.err);
203. //L.i("getPackageInfoerr="+e.getMessage());
204. }
205. if(info==null)
206. info=newPackageInfo();
207. returninfo;
208. }
210. }

转自：http://blog.csdn.net/way_ping_li/article/details/7927273