UncaughtExceptionHandler和Bugly结合

近日来，在Bugly中看到有SQLiteFullException上报，查看崩溃设备的信息，可用的存储空间几乎没有。
所以计划实现以下需求：

• 当应用崩溃后，针对特定异常弹出解决方案
• 不影响Bugly上报的功能

代码实现

在Android中，可以实现UncaughtExceptionHandler接口，并通过Thread.setDefaultUncaughtExceptionHandler()方法将自己的实现类设置为默认的异常处理类。

public class CrashHandler implements Thread.UncaughtExceptionHandler {

    private Thread.UncaughtExceptionHandler mDefaultUncaughtExceptionHandler;

    public static CrashHandler getInstance() {
        return CrashHandlerHolder.INSTANCE;
    }

    public void init() {
       /*
        * 弹出解决方案之后把崩溃继续交给系统处理，
        * 所以保存当前UncaughtExceptionHandler用于崩溃发生时使用。
        */
        mDefaultUncaughtExceptionHandler = Thread.getDefaultUncaughtExceptionHandler();
        Thread.setDefaultUncaughtExceptionHandler(this);
    }

    // 当有未截获的异常时，回调此方法
    @Override
    public void uncaughtException(Thread thread, Throwable ex) {
        if (ex instanceof SQLiteFullException) {
            showCrashHintActivity(ex);
        }
        // 传递给保存的UncaughtExceptionHandler
        mDefaultUncaughtExceptionHandler.uncaughtException(thread, ex);
    }

    private void showCrashHintActivity(Throwable ex) {
        Intent intent = new Intent(MyApplication.sContext, CrashHintActivity.class);
        intent.putExtra(CrashHintActivity.THROWABLE, ex);
        // 使用非Activity的Context启动Activity需要使用此标记位为它创建任务栈
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        MyApplication.sContext.startActivity(intent);
    }

    private static class CrashHandlerHolder {
        static final CrashHandler INSTANCE = new CrashHandler();
    }

    private CrashHandler() { }
}

CrashHintActivity用于崩溃后展示崩溃提示：

public class CrashHintActivity extends Activity {

    public static final String THROWABLE = "throwable";

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_crash);

        TextView tvHint = (TextView) findViewById(R.id.tv_crash);
        Throwable ex = (Throwable) getIntent().getSerializableExtra(THROWABLE);

        if (ex instanceof SQLiteFullException) {
            tvHint.setText(R.string.SQLiteFullException_hint);
        }
    }
}

在Application或者其他地方初始化自己的异常处理类和Bugly：

public class MyApplication extends Application {

    public static Context sContext;

    @Override
    public void onCreate() {
        super.onCreate();
        sContext = getApplicationContext();

        // init CrashHandler
        CrashHandler.getInstance().init();
        // init Bugly
        CrashReport.initCrashReport(this, "your Bugly App ID", false);
    }
}

建议异常处理类的初始化要放在Bugly初始化之前，因为Bugly也使用了同样的方法，先获取当前的UncaughtExceptionHandler，在发生崩溃后传递。
如果异常处理类初始化放在Bugly初始化之后，并且在异常发生时没有传递给保存的UncaughtExceptionHandler，崩溃信息则不会到达Bugly的实现类中，无法上报错误信息。

因为有混淆，省略了很多代码简要的看一下Bugly的实现类：

public final class e implements UncaughtExceptionHandler {

    private UncaughtExceptionHandler e;

    public final synchronized void a() {
        if(this.j >= 10) {
            w.a("java crash handler over %d, no need set.", new Object[]{Integer.valueOf(10)});
        } else {
            // var1保存当前的UncaughtExceptionHandler
            UncaughtExceptionHandler var1;
            if((var1 = Thread.getDefaultUncaughtExceptionHandler()) != null) {
                ···
                // 因为在Bugly之前替换了默认的UncaughtExceptionHandler，执行else
                if("com.android.internal.os.RuntimeInit$UncaughtHandler".equals(var1.getClass().getName())) {
                    w.a("backup system java handler: %s", new Object[]{var1.toString()});
                    this.f = var1;
                    this.e = var1;
                } else {
                    w.a("backup java handler: %s", new Object[]{var1.toString()});
                    // 将var1保存到成员变量e中
                    this.e = var1;
                }
            }
            Thread.setDefaultUncaughtExceptionHandler(this);
           ···
        }
    }

    // 当有未截获的异常时，回调此方法
    public final void uncaughtException(Thread var1, Throwable var2) {
        Object var3 = i;
        synchronized(i) {
            this.a(var1, var2, true, (String)null, (byte[])null);
        }
    }

    public final void a(Thread var1, Throwable var2, boolean var3, String var4, byte[] var5) {
        ···
        try {
            ···
        } catch (Throwable var9) {
            ···
        } finally {
            if(var3) {
                if(this.e != null && a(this.e)) {
                    w.e("sys default last handle start!", new Object[0]);
                    // 传递给保存的UncaughtExceptionHandler
                    this.e.uncaughtException(var1, var2);
                    w.e("sys default last handle end!", new Object[0]);
                } else if(this.f != null) {
                    ···
                } else {
                    ···
                }
            }
        }
    }
}

运行效果

屏幕截图
Bugly上报

最后

至此，一个简单的UncaughtExceptionHandler和Bugly结合使用的例子就介绍完毕了。
代码已同步至Github，GuJin/Crash.
谢谢大家。