Android全局捕获崩溃异常记录日志保存至本地并定时删除

一.概述

        发布过产品的android程序员都会知道，在程序发布出去之后，如果出现了崩溃现象，开发者应该及时获取在该设备上导致崩溃的信息，这对于下一个版本的bug修复帮助极大，尤其是某些不容易复现的bug，所以今天就来介绍一下如何在程序崩溃的情况下收集相关的设备参数信息和具体的异常信息，并发送这些信息到服务器供开发者分析和调试程序，并且定时删除这些日志文件。参考网上相关文章，自己做了部分改进和完善。

二.项目简介

项目结构如图：

MainActivity内的代码如下：

[java]  view plain  copy

1. package com.example.mycrashtest;  
2.   
3. import android.app.Activity;  
4. import android.os.Bundle;  
5. import android.view.Menu;  
6. import android.widget.TextView;  
7.   
8. public class MainActivity extends Activity {  
9.       
10.     private TextView tv;  
11.   
12.     @Override  
13.     protected void onCreate(Bundle savedInstanceState) {  
14.         super.onCreate(savedInstanceState);  
15.         setContentView(R.layout.activity_main);  
16.         tv.setText("我没初始化");  
17.     }  
18.   
19.     @Override  
20.     public boolean onCreateOptionsMenu(Menu menu) {  
21.         // Inflate the menu; this adds items to the action bar if it is present.  
22.         getMenuInflater().inflate(R.menu.main, menu);  
23.         return true;  
24.     }  
25.   
26. }  

在这里，我没对TextView进行初始化，直接给其进行设置文本，会造成运行时异常，没有对此异常进行处理，系统会弹出停止运行并强制关闭。

三.Appcation与Thread.UncaughtExceptionHandler

Appcation：Application和Activity,Service一样,是android框架的一个系统组件，当android程序启动时系统会创建一个 application对象，用来存储系统的一些信息。通常我们是不需要指定一个Application的，这时系统会自动帮我们创建，如果需要创建自己 的Application，也很简单创建一个类继承 Application并在manifest的application标签中进行注册(只需要给Application标签增加个name属性把自己的 Application的名字定入即可)。
    android系统会为每个程序运行时创建一个Application类的对象且仅创建一个，所以Application可以说是单例 (singleton)模式的一个类.且application对象的生命周期是整个程序中最长的，它的生命周期就等于这个程序的生命周期。因为它是全局 的单例的，所以在不同的Activity,Service中获得的对象都是同一个对象。所以通过Application来进行一些，数据传递，数据共享 等,数据缓存等操作。

Thread.UncaughtExceptionHandler：当某一线程因未捕获的异常而即将终止时，Java 虚拟机将使用  Thread.getUncaughtExceptionHandler() 查询该线程以获得其  UncaughtExceptionHandler 的线程，并调用处理程序的 uncaughtException 方法，将线程和异常作为参数传递。如果某一线程没有明确设置其 UncaughtExceptionHandler，则将它的 ThreadGroup 对象作为其 UncaughtExceptionHandler。如果 ThreadGroup 对象对处理异常没有什么特殊要求，那么它可以将调用转发给 默认的未捕获异常处理程序。
我们需要实现此接口，并注册为程序中默认未捕获异常处理。这样当未捕获异常发生时，就可以做一些个性化的异常处理操作。

四.代码实现

[java]  view plain  copy

1. <pre name="code" class="java">package com.example.mycrashtest;  
2.   
3. import java.io.File;  
4. import java.io.FileOutputStream;  
5. import java.io.FilenameFilter;  
6. import java.io.PrintWriter;  
7. import java.io.StringWriter;  
8. import java.io.Writer;  
9. import java.lang.Thread.UncaughtExceptionHandler;  
10. import java.lang.reflect.Field;  
11. import java.text.DateFormat;  
12. import java.text.SimpleDateFormat;  
13. import java.util.Date;  
14. import java.util.HashMap;  
15. import java.util.Map;  
16.   
17. import android.annotation.SuppressLint;  
18. import android.content.Context;  
19. import android.content.Intent;  
20. import android.content.pm.PackageInfo;  
21. import android.content.pm.PackageManager;  
22. import android.content.pm.PackageManager.NameNotFoundException;  
23. import android.os.Build;  
24. import android.os.Environment;  
25. import android.os.Looper;  
26. import android.os.SystemClock;  
27. import android.util.Log;  
28. import android.widget.Toast;  
29.   
30. /** 
31.  * <h3>全局捕获异常</h3> 
32.  * <br> 
33.  * 当程序发生Uncaught异常的时候,有该类来接管程序,并记录错误日志 
34.  *  
35.  */  
36. @SuppressLint("SimpleDateFormat")  
37. public class CrashHandler implements UncaughtExceptionHandler {  
38.   
39.     public static String TAG = "MyCrash";  
40.     // 系统默认的UncaughtException处理类  
41.     private Thread.UncaughtExceptionHandler mDefaultHandler;  
42.   
43.     private static CrashHandler instance = new CrashHandler();  
44.     private Context mContext;  
45.   
46.     // 用来存储设备信息和异常信息  
47.     private Map<String, String> infos = new HashMap<String, String>();  
48.   
49.     // 用于格式化日期,作为日志文件名的一部分  
50.     private DateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");  
51.   
52.     /** 保证只有一个CrashHandler实例 */  
53.     private CrashHandler() {  
54.     }  
55.   
56.     /** 获取CrashHandler实例 ,单例模式 */  
57.     public static CrashHandler getInstance() {  
58.         return instance;  
59.     }  
60.   
61.     /** 
62.      * 初始化 
63.      *  
64.      * @param context 
65.      */  
66.     public void init(Context context) {  
67.         mContext = context;  
68.         // 获取系统默认的UncaughtException处理器  
69.         mDefaultHandler = Thread.getDefaultUncaughtExceptionHandler();  
70.         // 设置该CrashHandler为程序的默认处理器  
71.         Thread.setDefaultUncaughtExceptionHandler(this);  
72.         autoClear(5);  
73.     }  
74.   
75.     /** 
76.      * 当UncaughtException发生时会转入该函数来处理 
77.      */  
78.     @Override  
79.     public void uncaughtException(Thread thread, Throwable ex) {  
80.         if (!handleException(ex) && mDefaultHandler != null) {  
81.             // 如果用户没有处理则让系统默认的异常处理器来处理  
82.             mDefaultHandler.uncaughtException(thread, ex);  
83.         } else {  
84.             SystemClock.sleep(3000);  
85.             // 退出程序  
86.             android.os.Process.killProcess(android.os.Process.myPid());  
87.             System.exit(1);  
88.         }  
89.     }  
90.   
91.     /** 
92.      * 自定义错误处理,收集错误信息 发送错误报告等操作均在此完成. 
93.      *  
94.      * @param ex 
95.      * @return true:如果处理了该异常信息; 否则返回false. 
96.      */  
97.     private boolean handleException(Throwable ex) {  
98.         if (ex == null)  
99.             return false;  
100.   
101.         try {  
102.             // 使用Toast来显示异常信息  
103.             new Thread() {  
104.   
105.                 @Override  
106.                 public void run() {  
107.                     Looper.prepare();  
108.                     Toast.makeText(mContext, "很抱歉,程序出现异常,即将重启.",  
109.                             Toast.LENGTH_LONG).show();  
110.                     Looper.loop();  
111.                 }  
112.             }.start();  
113.             // 收集设备参数信息  
114.             collectDeviceInfo(mContext);  
115.             // 保存日志文件  
116.             saveCrashInfoFile(ex);  
117.             SystemClock.sleep(3000);  
118.         } catch (Exception e) {  
119.             e.printStackTrace();  
120.         }  
121.   
122.         return true;  
123.     }  
124.   
125.     /** 
126.      * 收集设备参数信息 
127.      *  
128.      * @param ctx 
129.      */  
130.     public void collectDeviceInfo(Context ctx) {  
131.         try {  
132.             PackageManager pm = ctx.getPackageManager();  
133.             PackageInfo pi = pm.getPackageInfo(ctx.getPackageName(),  
134.                     PackageManager.GET_ACTIVITIES);  
135.             if (pi != null) {  
136.                 String versionName = pi.versionName + "";  
137.                 String versionCode = pi.versionCode + "";  
138.                 infos.put("versionName", versionName);  
139.                 infos.put("versionCode", versionCode);  
140.             }  
141.         } catch (NameNotFoundException e) {  
142.             Log.e(TAG, "an error occured when collect package info", e);  
143.         }  
144.         Field[] fields = Build.class.getDeclaredFields();  
145.         for (Field field : fields) {  
146.             try {  
147.                 field.setAccessible(true);  
148.                 infos.put(field.getName(), field.get(null).toString());  
149.             } catch (Exception e) {  
150.                 Log.e(TAG, "an error occured when collect crash info", e);  
151.             }  
152.         }  
153.     }  
154.   
155.     /** 
156.      * 保存错误信息到文件中 
157.      * @param ex 
158.      * @return 返回文件名称,便于将文件传送到服务器 
159.      * @throws Exception 
160.      */  
161.     private String saveCrashInfoFile(Throwable ex) throws Exception {  
162.         StringBuffer sb = new StringBuffer();  
163.         try {  
164.             SimpleDateFormat sDateFormat = new SimpleDateFormat(  
165.                     "yyyy-MM-dd HH:mm:ss");  
166.             String date = sDateFormat.format(new java.util.Date());  
167.             sb.append("\r\n" + date + "\n");  
168.             for (Map.Entry<String, String> entry : infos.entrySet()) {  
169.                 String key = entry.getKey();  
170.                 String value = entry.getValue();  
171.                 sb.append(key + "=" + value + "\n");  
172.             }  
173.   
174.             Writer writer = new StringWriter();  
175.             PrintWriter printWriter = new PrintWriter(writer);  
176.             ex.printStackTrace(printWriter);  
177.             Throwable cause = ex.getCause();  
178.             while (cause != null) {  
179.                 cause.printStackTrace(printWriter);  
180.                 cause = cause.getCause();  
181.             }  
182.             printWriter.flush();  
183.             printWriter.close();  
184.             String result = writer.toString();  
185.             sb.append(result);  
186.   
187.             String fileName = writeFile(sb.toString());  
188.             return fileName;  
189.         } catch (Exception e) {  
190.             Log.e(TAG, "an error occured while writing file...", e);  
191.             sb.append("an error occured while writing file...\r\n");  
192.             writeFile(sb.toString());  
193.         }  
194.         return null;  
195.     }  
196.   
197.     private String writeFile(String sb) throws Exception {  
198.         String time = formatter.format(new Date());  
199.         String fileName = "crash-" + time + ".log";  
200.         if (FileUtil.hasSdcard()) {  
201.             String path = getGlobalpath();  
202.             File dir = new File(path);  
203.             if (!dir.exists())  
204.                 dir.mkdirs();  
205.   
206.             FileOutputStream fos = new FileOutputStream(path + fileName, true);  
207.             fos.write(sb.getBytes());  
208.             fos.flush();  
209.             fos.close();  
210.         }  
211.         return fileName;  
212.     }  
213.   
214.     public static String getGlobalpath() {  
215.         return Environment.getExternalStorageDirectory().getAbsolutePath()  
216.                 + File.separator + "crash" + File.separator;  
217.     }  
218.       
219.     public static void setTag(String tag) {  
220.         TAG = tag;  
221.     }  
222.       
223.     /** 
224.      * 文件删除 
225.      * @param day 文件保存天数 
226.      */  
227.     public void autoClear(final int autoClearDay) {  
228.         FileUtil.delete(getGlobalpath(), new FilenameFilter() {  
229.   
230.             @Override  
231.             public boolean accept(File file, String filename) {  
232.                 String s = FileUtil.getFileNameWithoutExtension(filename);  
233.                 int day = autoClearDay < 0 ? autoClearDay : -1 * autoClearDay;  
234.                 String date = "crash-" + DateUtil.getOtherDay(day);  
235.                 return date.compareTo(s) >= 0;  
236.             }  
237.         });  
238.           
239.     }  
240.   
241. }  

需要在自己的Appcation类中初始化这个CrashHandler：

[java]  view plain  copy

1. package com.example.mycrashtest;  
2.   
3. import android.app.Application;  
4.   
5. public class MyAppcation extends Application{  
6.       
7.     @Override  
8.     public void onCreate() {  
9.         super.onCreate();  
10.         CrashHandler.getInstance().init(this);  
11.     }  
12.   
13. }  

在AndroidManifest.xml文件中需要修改为自己的Appcation,并且加入操作SDCARD权限（写日志）：

四.运行结果

系统会自动在SDCARD下创建crash目录：


打开该文件：


至此，整个项目梳理完毕，关于将日志文件上传FTP，后面会另外讲述，部分知识本人也处于学习阶段，不足之处望大家谅解并提出，共同学习，谢谢！

项目下载： 点击打开链接