android 捕获未try的异常、抓取崩溃日志

1.Thread.UncaughtExceptionHandler

　　java里有很多异常如：空指针异常，越界异常，数值转换异常，除0异常，数据库异常等等。如果自己没有try / catch 那么线程就崩溃。

　　并不能对所有代码都try/catch，如果代码产生了未捕获的异常，又不想让程序崩溃，或者在崩溃之前要做一些收尾工作。怎么办？

　　Thread.UncaughtExceptionHandler 类可以解决这个问题，当有未捕获异常时，它的 public void uncaughtException(Thread t, Throwable e) 方法会被调用，参数包含了崩溃的线程及相应的异常信息。

　　Thread类中的 public static void setDefaultUncaughtExceptionHandler(UncaughtExceptionHandler eh) 方法指定接收未捕获异常处理类。通常在 Application 里指定一个生命周期很长的未捕获异常处理类。

2.示例

2.1 自定义Thread.UncaughtExceptionHandler

 import android.content.Context
 import android.content.pm.PackageManager
 import android.os.Build
 import java.io.File
 import java.io.PrintWriter
 import java.text.SimpleDateFormat
 import java.util.*

 class CrashHandler(val context: Context) : Thread.UncaughtExceptionHandler {

     private lateinit var default : Thread.UncaughtExceptionHandler
     override fun uncaughtException(t: Thread, e: Throwable) {
         e.printStackTrace()
         writeLog(t,e)
         if (::default.isInitialized){
             default.uncaughtException(t,e)
         }
     }

     fun start(){
         default = Thread.getDefaultUncaughtExceptionHandler()
         Thread.setDefaultUncaughtExceptionHandler(this)
     }

     fun writeLog(t: Thread, e: Throwable){
         val log = context.getExternalFilesDir("")?.absolutePath + "/crash.log"
         val time = SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(Date())
         try {
             val file = File(log)
             val pw = PrintWriter(file,"UTF-8")
             pw.println("time        : $time")
             pw.println("Thread      : name = ${t.name} ,priority = ${t.priority} , pid = ${t.id}")
             writePhoneInfo(pw)
             e.printStackTrace(pw)
             pw.close()
         }catch (e : Exception){
             e.printStackTrace()
         }
     }
     fun writePhoneInfo(pw : PrintWriter) {
         val pm = context.getPackageManager()
         val pi = pm.getPackageInfo(context.packageName,PackageManager.GET_ACTIVITIES)

         pw.println("app version : ${pi.versionName}")
         pw.println("android ver : ${Build.VERSION.RELEASE}")
         pw.println("sdk version : ${Build.VERSION.SDK_INT}")
         pw.println("product     : ${Build.PRODUCT}")

         pw.println("vendor      : ${Build.MANUFACTURER}")
         pw.println("brand       : ${Build.BRAND}")
         pw.println("model       : ${Build.MODEL}")
         pw.println("hardware    : ${Build.HARDWARE}")

         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
             var abis = ""
             for (abi in Build.SUPPORTED_ABIS){
                 abis += "$abi,"
             }
             pw.println("CPU_abis    : ${abis}")
         }else{
             pw.println("CPU_abi     : ${Build.CPU_ABI}")
         }
     }
 }

如图：

2.2 在application里注册

     lateinit var crash      :   CrashHandler
     fun crashHandler(){
         crash = CrashHandler(context = applicationContext)
         crash.start()
     }

2.3 在自定义的线程中注册

  private void init(){

         new Thread(){
             @Override
             public void run() {
                 setUncaughtExceptionHandler(crashHandler);
                 int num =  / ;
             }
         }.start();
     }
     public CrashHandler crashHandler = new CrashHandler();
     public class CrashHandler implements Thread.UncaughtExceptionHandler {
         final String TAG = "CrashHandler";

         @Override
         public void uncaughtException(Thread t, Throwable e) {
             e.printStackTrace();
             Log.e(TAG, "uncaughtException: " + e.getMessage() + " thread = " + t.getId());
             if (t.getId() == ){
                 //...
             }
             //异常信息收集
             //应用程序信息收集
             //保存错误报告文件到文件。
         }
     }