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 = 100 / 0;
            }
        }.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() == 1){
                //...
            }
            //异常信息收集
            //应用程序信息收集
            //保存错误报告文件到文件。
        }
    }