自定义捕获全局异常

移动开发 waitig 532℃ 百度已收录 0评论
  1. import java.io.File;  
  2. import java.io.FileOutputStream;  
  3. import java.io.PrintWriter;  
  4. import java.io.StringWriter;  
  5. import java.io.Writer;  
  6. import java.lang.Thread.UncaughtExceptionHandler;  
  7. import java.lang.reflect.Field;  
  8. import java.text.DateFormat;  
  9. import java.text.SimpleDateFormat;  
  10. import java.util.Date;  
  11. import java.util.HashMap;  
  12. import java.util.Map;  
  13.   
  14. import android.content.Context;  
  15. import android.content.pm.PackageInfo;  
  16. import android.content.pm.PackageManager;  
  17. import android.content.pm.PackageManager.NameNotFoundException;  
  18. import android.os.Build;  
  19. import android.os.Environment;  
  20. import android.os.Looper;  
  21. import android.util.Log;  
  22. import android.widget.Toast;  
  23.   
  24. /** 
  25.  * UncaughtException处理类,当程序发生Uncaught异常的时候,有该类来接管程序,并记录发送错误报告. 
  26.  *  
  27.  * @author user 
  28.  *  
  29.  */  
  30. public class CrashHandler implements UncaughtExceptionHandler {  
  31.       
  32.     public static final String TAG = "CrashHandler";  
  33.       
  34.     //系统默认的UncaughtException处理类   
  35.     private Thread.UncaughtExceptionHandler mDefaultHandler;  
  36.     //CrashHandler实例  
  37.     private static CrashHandler INSTANCE = new CrashHandler();  
  38.     //程序的Context对象  
  39.     private Context mContext;  
  40.     //用来存储设备信息和异常信息  
  41.     private Map<String, String> infos = new HashMap<String, String>();  
  42.   
  43.     //用于格式化日期,作为日志文件名的一部分  
  44.     private DateFormat formatter = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss");  
  45.   
  46.     /** 保证只有一个CrashHandler实例 */  
  47.     private CrashHandler() {  
  48.     }  
  49.   
  50.     /** 获取CrashHandler实例 ,单例模式 */  
  51.     public static CrashHandler getInstance() {  
  52.         return INSTANCE;  
  53.     }  
  54.   
  55.     /** 
  56.      * 初始化 
  57.      *  
  58.      * @param context 
  59.      */  
  60.     public void init(Context context) {  
  61.         mContext = context;  
  62.         //获取系统默认的UncaughtException处理器  
  63.         mDefaultHandler = Thread.getDefaultUncaughtExceptionHandler();  
  64.         //设置该CrashHandler为程序的默认处理器  
  65.         Thread.setDefaultUncaughtExceptionHandler(this);  
  66.     }  
  67.   
  68.     /** 
  69.      * 当UncaughtException发生时会转入该函数来处理 
  70.      */  
  71.     @Override  
  72.     public void uncaughtException(Thread thread, Throwable ex) {  
  73.         if (!handleException(ex) && mDefaultHandler != null) {  
  74.             //如果用户没有处理则让系统默认的异常处理器来处理  
  75.             mDefaultHandler.uncaughtException(thread, ex);  
  76.         } else {  
  77.             try {  
  78.                 Thread.sleep(3000);  
  79.             } catch (InterruptedException e) {  
  80.                 Log.e(TAG, "error : ", e);  
  81.             }  
  82.             //退出程序  
  83.             android.os.Process.killProcess(android.os.Process.myPid());  
  84.             System.exit(1);  
  85.         }  
  86.     }  
  87.   
  88.     /** 
  89.      * 自定义错误处理,收集错误信息 发送错误报告等操作均在此完成. 
  90.      *  
  91.      * @param ex 
  92.      * @return true:如果处理了该异常信息;否则返回false. 
  93.      */  
  94.     private boolean handleException(Throwable ex) {  
  95.         if (ex == null) {  
  96.             return false;  
  97.         }  
  98.         //使用Toast来显示异常信息  
  99.         new Thread() {  
  100.             @Override  
  101.             public void run() {  
  102.                 Looper.prepare();  
  103.                 Toast.makeText(mContext, "很抱歉,程序出现异常,即将退出.", Toast.LENGTH_LONG).show();  
  104.                 Looper.loop();  
  105.             }  
  106.         }.start();  
  107.         //收集设备参数信息   
  108.         collectDeviceInfo(mContext);  
  109.         //保存日志文件   
  110.         saveCrashInfo2File(ex);  
  111.         return true;  
  112.     }  
  113.       
  114.     /** 
  115.      * 收集设备参数信息 
  116.      * @param ctx 
  117.      */  
  118.     public void collectDeviceInfo(Context ctx) {  
  119.         try {  
  120.             PackageManager pm = ctx.getPackageManager();  
  121.             PackageInfo pi = pm.getPackageInfo(ctx.getPackageName(), PackageManager.GET_ACTIVITIES);  
  122.             if (pi != null) {  
  123.                 String versionName = pi.versionName == null ? "null" : pi.versionName;  
  124.                 String versionCode = pi.versionCode + "";  
  125.                 infos.put("versionName", versionName);  
  126.                 infos.put("versionCode", versionCode);  
  127.             }  
  128.         } catch (NameNotFoundException e) {  
  129.             Log.e(TAG, "an error occured when collect package info", e);  
  130.         }  
  131.         Field[] fields = Build.class.getDeclaredFields();  
  132.         for (Field field : fields) {  
  133.             try {  
  134.                 field.setAccessible(true);  
  135.                 infos.put(field.getName(), field.get(null).toString());  
  136.                 Log.d(TAG, field.getName() + " : " + field.get(null));  
  137.             } catch (Exception e) {  
  138.                 Log.e(TAG, "an error occured when collect crash info", e);  
  139.             }  
  140.         }  
  141.     }  
  142.   
  143.     /** 
  144.      * 保存错误信息到文件中 
  145.      *  
  146.      * @param ex 
  147.      * @return  返回文件名称,便于将文件传送到服务器 
  148.      */  
  149.     private String saveCrashInfo2File(Throwable ex) {  
  150.           
  151.         StringBuffer sb = new StringBuffer();  
  152.         for (Map.Entry<String, String> entry : infos.entrySet()) {  
  153.             String key = entry.getKey();  
  154.             String value = entry.getValue();  
  155.             sb.append(key + "=" + value + "\n");  
  156.         }  
  157.           
  158.         Writer writer = new StringWriter();  
  159.         PrintWriter printWriter = new PrintWriter(writer);  
  160.         ex.printStackTrace(printWriter);  
  161.         Throwable cause = ex.getCause();  
  162.         while (cause != null) {  
  163.             cause.printStackTrace(printWriter);  
  164.             cause = cause.getCause();  
  165.         }  
  166.         printWriter.close();  
  167.         String result = writer.toString();  
  168.         sb.append(result);  
  169.         try {  
  170.             long timestamp = System.currentTimeMillis();  
  171.             String time = formatter.format(new Date());  
  172.             String fileName = "crash-" + time + "-" + timestamp + ".log";  
  173.             if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {  
  174.             //String path="mnt/sdcard/";
  175.                 File dir = new File(path);  
  176.                 if (!dir.exists()) {  
  177.                     dir.mkdirs();  
  178.                 }  
  179.                 FileOutputStream fos = new FileOutputStream(path + fileName);  
  180.                 fos.write(sb.toString().getBytes());  
  181.                 fos.close();  
  182.             }  
  183.             return fileName;  
  184.         } catch (Exception e) {  
  185.             Log.e(TAG, "an error occured while writing file…", e);  
  186.         }  
  187.         return null;  
  188.     }  
  189. }  

//创建一个类继承Application,写上关联即可

  1. public class CrashApplication extends Application {  
  2.     @Override  
  3.     public void onCreate() {  
  4.         super.onCreate();  
  5.         CrashHandler crashHandler = CrashHandler.getInstance();  
  6.         crashHandler.init(getApplicationContext());  
  7.     }  
  8. }  


本文由【waitig】发表在等英博客
本文固定链接:自定义捕获全局异常
欢迎关注本站官方公众号,每日都有干货分享!
等英博客官方公众号
点赞 (0)分享 (0)