转--全局异常处理

本文将分析在程序出错的情况下如何收集相关的错误信息，并发送错误信息到服务器供开发者分析和调试程序。错误信息将成为您Debug的一把利刃，通过错误信息您可以最及时的掌握程序在各个系统版本和设备上的运行情况。

错误处理介绍

在一般情况下，OPhone程序出错都会出现一个提示对话框
这种情况下，用户只有点击“强行关闭”来结束程序。当该对话框出现对用户来说是相当不友好的，本文中将会告诉您如何在程序出错时不显示该对话框。
随着OPhone设备和系统版本的增加，现在在不同设备和版本上调试程序越来越麻烦，开发者不可能购买所有的设备来逐个调试程序。如果程序在模拟器上运行正常但是到最终用户手中运行却出现了错误，这种情况下如果可以收集到程序错误堆栈信息和具体设备的信息，对开发者调试程序就有莫大的帮助了。
要收集错误信息，我们需要了解两个主要接口API的使用：Android.app.Application 和java.lang.Thread.UncaughtExceptionHandler 。下面就对着两个API做简单介绍。

UncaughtExceptionHandler：线程未捕获异常控制器是用来处理未捕获异常的。如果程序出现了未捕获异常默认情况下则会出现上面所示的强行关闭对话框。在本文将实现该接口并注册为程序中的默认未捕获异常处理。这样当未捕获异常发生时，就可以做些异常处理操作，例如：收集异常信息，发送错误报告 等。

Application：在开发OPhone应用时都会和Activity打交道，而Application使用的就相对较少了。Application 在OPhone中是用来管理应用程序的全局状态的，比如载入资源文件。在应用程序启动的时候Application会首先创建，然后才会根据情况（Intent）来启动相应的Activity或者Service。在本文将在Application中注册未捕获异常处理器。

UncaughtExceptionHandler接口实现

首先创建一个OPhone项目（项目的创建请参考OPhoneSDN上的其他文章），本文示例项目名称为：CrashReporter ；包名为：org.goodev.cr；并创建一个默认的Activity名字为：ReporterTest。然后创建CrashHandler类实现UncaughtExceptionHandler接口，并实现其函数：public void uncaughtException(Thread thread, Throwable ex)。CrashHandler类实现了错误报告的主要处理逻辑，该类代码如下（在代码中会有详细注释来解释各种处理情况）：

1. package org.goodev.cr;   
2.   
3. Import 省略...；   
4. /**  
5.  * UncaughtException处理类,当程序发生Uncaught异常的时候,有该类  
6.  * 来接管程序,并记录 发送错误报告.  
7.  *  
8.  */  
9. public class CrashHandler implements UncaughtExceptionHandler {   
10.     /** Debug Log tag*/  
11.     public static final String TAG = "CrashHandler";   
12.     /** 是否开启日志输出,在Debug状态下开启,  
13.      * 在Release状态下关闭以提示程序性能  
14.      * */  
15.     public static final boolean DEBUG = true;   
16.     /** 系统默认的UncaughtException处理类 */  
17.     private Thread.UncaughtExceptionHandler mDefaultHandler;   
18.     /** CrashHandler实例 */  
19.     private static CrashHandler INSTANCE;   
20.     /** 程序的Context对象 */  
21.     private Context mContext;   
22.        
23.     /** 使用Properties来保存设备的信息和错误堆栈信息*/  
24.     private Properties mDeviceCrashInfo = new Properties();   
25.     private static final String VERSION_NAME = "versionName";   
26.     private static final String VERSION_CODE = "versionCode";   
27.     private static final String STACK_TRACE = "STACK_TRACE";   
28.     /** 错误报告文件的扩展名 */  
29.     private static final String CRASH_REPORTER_EXTENSION = ".cr";   
30.        
31.     /** 保证只有一个CrashHandler实例 */  
32.     private CrashHandler() {}   
33.     /** 获取CrashHandler实例 ,单例模式*/  
34.     public static CrashHandler getInstance() {   
35.         if (INSTANCE == null) {   
36.             INSTANCE = new CrashHandler();   
37.         }   
38.         return INSTANCE;   
39.     }   
40.   
41.     /**  
42.      * 初始化,注册Context对象,  
43.      * 获取系统默认的UncaughtException处理器,  
44.      * 设置该CrashHandler为程序的默认处理器  
45.      *   
46.      * @param ctx  
47.      */  
48.     public void init(Context ctx) {   
49.         mContext = ctx;   
50.         mDefaultHandler = Thread.getDefaultUncaughtExceptionHandler();   
51.         Thread.setDefaultUncaughtExceptionHandler(this);   
52.     }   
53.   
54.     /**  
55.      * 当UncaughtException发生时会转入该函数来处理  
56.      */  
57.     @Override  
58.     public void uncaughtException(Thread thread, Throwable ex) {   
59.         if (!handleException(ex) && mDefaultHandler != null) {   
60.             //如果用户没有处理则让系统默认的异常处理器来处理   
61.             mDefaultHandler.uncaughtException(thread, ex);   
62.         } else {   
63.             //Sleep一会后结束程序   
64.             try {   
65.                 Thread.sleep(3000);   
66.             } catch (InterruptedException e) {   
67.                 Log.e(TAG, "Error : ", e);   
68.             }   
69.             Android.os.Process.killProcess(android.os.Process.myPid());   
70.             System.exit(10);   
71.         }   
72.     }   
73.   
74.     /**  
75.      * 自定义错误处理,收集错误信息  
76.      * 发送错误报告等操作均在此完成.  
77.      * 开发者可以根据自己的情况来自定义异常处理逻辑  
78.      * @param ex  
79.      * @return true:如果处理了该异常信息;否则返回false  
80.      */  
81.     private boolean handleException(Throwable ex) {   
82.         if (ex == null) {   
83.             return true;   
84.         }   
85.         final String msg = ex.getLocalizedMessage();   
86.         //使用Toast来显示异常信息   
87.         new Thread() {   
88.             @Override  
89.             public void run() {   
90.                 Looper.prepare();   
91.                 Toast.makeText(mContext, "程序出错啦:" + msg, Toast.LENGTH_LONG)   
92.                         .show();   
93.                 Looper.loop();   
94.             }   
95.   
96.         }.start();   
97.         //收集设备信息   
98.         collectCrashDeviceInfo(mContext);   
99.         //保存错误报告文件   
100.         String crashFileName = saveCrashInfoToFile(ex);   
101.         //发送错误报告到服务器   
102.         sendCrashReportsToServer(mContext);   
103.         return true;   
104.     }   
105.   
106.     /**  
107.      * 在程序启动时候, 可以调用该函数来发送以前没有发送的报告  
108.      */  
109.     public void sendPreviousReportsToServer() {   
110.         sendCrashReportsToServer(mContext);   
111.     }   
112.   
113.     /**  
114.      * 把错误报告发送给服务器,包含新产生的和以前没发送的.  
115.      *   
116.      * @param ctx  
117.      */  
118.     private void sendCrashReportsToServer(Context ctx) {   
119.         String[] crFiles = getCrashReportFiles(ctx);   
120.         if (crFiles != null && crFiles.length > 0) {   
121.             TreeSet<String> sortedFiles = new TreeSet<String>();   
122.             sortedFiles.addAll(Arrays.asList(crFiles));   
123.   
124.             for (String fileName : sortedFiles) {   
125.                 File cr = new File(ctx.getFilesDir(), fileName);   
126.                 postReport(cr);   
127.                 cr.delete();// 删除已发送的报告   
128.             }   
129.         }   
130.     }   
131.   
132.     private void postReport(File file) {   
133.         // TODO 使用HTTP Post 发送错误报告到服务器   
134.         // 这里不再详述,开发者可以根据OPhoneSDN上的其他网络操作   
135.         // 教程来提交错误报告   
136.     }   
137.   
138.     /**  
139.      * 获取错误报告文件名  
140.      * @param ctx  
141.      * @return  
142.      */  
143.     private String[] getCrashReportFiles(Context ctx) {   
144.         File filesDir = ctx.getFilesDir();   
145.         FilenameFilter filter = new FilenameFilter() {   
146.             public boolean accept(File dir, String name) {   
147.                 return name.endsWith(CRASH_REPORTER_EXTENSION);   
148.             }   
149.         };   
150.         return filesDir.list(filter);   
151.     }   
152.     /**  
153.      * 保存错误信息到文件中  
154.      * @param ex  
155.      * @return  
156.      */  
157.     private String saveCrashInfoToFile(Throwable ex) {   
158.         Writer info = new StringWriter();   
159.         PrintWriter printWriter = new PrintWriter(info);   
160.         ex.printStackTrace(printWriter);   
161.   
162.         Throwable cause = ex.getCause();   
163.         while (cause != null) {   
164.             cause.printStackTrace(printWriter);   
165.             cause = cause.getCause();   
166.         }   
167.   
168.         String result = info.toString();   
169.         printWriter.close();   
170.         mDeviceCrashInfo.put(STACK_TRACE, result);   
171.   
172.         try {   
173.             long timestamp = System.currentTimeMillis();   
174.             String fileName = "crash-" + timestamp + CRASH_REPORTER_EXTENSION;   
175.             FileOutputStream trace = mContext.openFileOutput(fileName,   
176.                     Context.MODE_PRIVATE);   
177.             mDeviceCrashInfo.store(trace, "");   
178.             trace.flush();   
179.             trace.close();   
180.             return fileName;   
181.         } catch (Exception e) {   
182.             Log.e(TAG, "an error occured while writing report file...", e);   
183.         }   
184.         return null;   
185.     }   
186.   
187.   
188.     /**  
189.      * 收集程序崩溃的设备信息  
190.      *   
191.      * @param ctx  
192.      */  
193.     public void collectCrashDeviceInfo(Context ctx) {   
194.         try {   
195.             PackageManager pm = ctx.getPackageManager();   
196.             PackageInfo pi = pm.getPackageInfo(ctx.getPackageName(),   
197.                     PackageManager.GET_ACTIVITIES);   
198.             if (pi != null) {   
199.                 mDeviceCrashInfo.put(VERSION_NAME,   
200.                         pi.versionName == null ? "not set" : pi.versionName);   
201.                 mDeviceCrashInfo.put(VERSION_CODE, pi.versionCode);   
202.             }   
203.         } catch (NameNotFoundException e) {   
204.             Log.e(TAG, "Error while collect package info", e);   
205.         }   
206.         //使用反射来收集设备信息.在Build类中包含各种设备信息,   
207.         //例如: 系统版本号,设备生产商 等帮助调试程序的有用信息   
208. //具体信息请参考后面的截图   
209.         Field[] fields = Build.class.getDeclaredFields();   
210.         for (Field field : fields) {   
211.             try {   
212.                 field.setAccessible(true);   
213.                 mDeviceCrashInfo.put(field.getName(), field.get(null));   
214.                 if (DEBUG) {   
215.                     Log.d(TAG, field.getName() + " : " + field.get(null));   
216.                 }   
217.             } catch (Exception e) {   
218.                 Log.e(TAG, "Error while collect crash info", e);   
219.             }   
220.   
221.         }   
222.   
223.     }   
224.   
225. }  

在上面CrashHandler实现中，当错误发生的时候使用Toast显示错误信息，然后收集错误报告并保存在文件中。 发送错误报告代码请读者自己实现。在uncaughtException函数中调用了Thread.sleep(3000)；来让线程停止一会是为了显示Toast信息给用户，然后Kill程序。如果你不用Toast来显示信息则可以去除该代码。除了Toast外，开发者还可以选择使用Notification来显示错误内容并让用户选择是否提交错误报告而不是自动提交。关于Notification的实现请读者参考：NotificationManager。在发送错误报道的时候，可以先检测网络是否可用，如果不可用则可以在以后网络情况可用的情况下发送。 网络监测代码如下：

1. /**  
2.      * 检测网络连接是否可用  
3.      * @param ctx  
4.      * @return true 可用; false 不可用  
5.      */  
6.     private boolean isNetworkAvailable(Context ctx) {   
7.         ConnectivityManager cm =    
8.             (ConnectivityManager) ctx.getSystemService(Context.CONNECTIVITY_SERVICE);   
9.         if(cm == null) {   
10.             return false;   
11.         }   
12.         NetworkInfo[] netinfo = cm.getAllNetworkInfo();   
13.         if(netinfo == null) {   
14.             return false;   
15.         }   
16.         for (int i = 0; i < netinfo.length; i++) {   
17.             if(netinfo[i].isConnected()) {   
18.                 return true;   
19.             }   
20.         }   
21.         return false;   
22.     }  

Application 实现

实现一个自定义Application来注册CrashHandler. 代码如下:

1. public class CrashApplication extends Application {   
2.   
3.     @Override  
4.     public void onCreate() {   
5.         super.onCreate();   
6.         CrashHandler crashHandler = CrashHandler.getInstance();   
7.         //注册crashHandler   
8.         crashHandler.init(getApplicationContext());   
9.         //发送以前没发送的报告(可选)   
10.         crashHandler.sendPreviousReportsToServer();   
11.     }   
12.        
13. }  

在AndroidManifest.xml中注册

最后只要在AndroidManifest.xml中注册CrashApplication就可以了。代码如下：

1. <?xml version="1.0" encoding="utf-8"?>  
2. <manifest xmlns:Android="http://schemas.android.com/apk/res/android"  
3.       package="org.goodev.cr"  
4.       Android:versionCode="1"  
5.       Android:versionName="1.0">  
6.     <application Android:icon="@drawable/icon" android:label="@string/app_name"    
7.         Android:name=".CrashApplication">  
8.         <activity Android:name=".ReporterTest"  
9.                   Android:label="@string/app_name">  
10.             <intent-filter>  
11.                 <action Android:name="android.intent.action.MAIN" />  
12.                 <category Android:name="android.intent.category.LAUNCHER" />  
13.             </intent-filter>  
14.         </activity>  
15.     </application>  
16. </manifest>   

  

总结：通过本文示例的方式，开发者可以在程序中收集详细的崩溃信息，从而为调试程序带来便利，如果您的程序还没有该功能赶快加入吧。crashReporter.zip中包含本文使用的项目文件及资源。