android 程序漰溃 后台handle处理类

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值