android捕获全局异常

引出

android程序在运行的时候，当Thread 因未捕获的异常而突然终止时，我们无法获取异常信息，因此需要调用处理程序的接口。

大家都知道，现在安装 Android 系统的手机和设备千差万别，在模拟器上运行良好的程序安装到某款手机上说不定就出现崩溃的现象，开发者个人不可能购买所有设备逐个调试，所以在程序发布出去之后，如果出现了崩溃现象，开发者应该及时获取在该设备上导致崩溃的信息，这对于下一个版本的 BUG 修复帮助极大，所以今天就来介绍一下如何在程序崩溃的情况下收集相关的设备参数信息和具体的异常信息，并发送这些信息到服务器供开发者分析和调试程序。

今天来实现在Android中自定义捕获Application全局异常，可以替换掉系统的强制退出对话框（很有参考价值与实用价值），并提供可扩展的异常处理机制。

解决办法

遇到软件没有捕获的异常之后，系统会弹出这个默认的强制关闭对话框。

我们当然不希望用户看到这种现象，简直是对用户心灵上的打击，而且对我们的 BUG 的修复也是毫无帮助的。我们需要的是软件有一个全局的异常捕获器，当出现一个我们没有发现的异常时，捕获这个异常，并且将异常信息记录下来，上传到服务器供开发这分析出现异常的具体原因。

接下来我们就来实现这一机制，不过首先我们还是来了解以下两个类：android.app.Application 和java.lang.Thread.UncaughtExceptionHandler。

1、Application：用来管理应用程序的全局状态。在应用程序启动时 Application 会首先创建，然后才会根据情况（Intent）来启动相应的Activity 和 Service。本示例中将在自定义加强版的 Application 中注册未捕获异常处理器。

2、Thread.UncaughtExceptionHandler：线程未捕获异常处理器，用来处理未捕获异常。如果程序出现了未捕获异常，默认会弹出系统中强制关闭对话框。我们需要实现此接口，并注册为程序中默认未捕获异常处理。这样当未捕获异常发生时，就可以做一些个性化的异常处理操作。

下面我们来实现这一操作：

首先实现自定义异常处理类：

/**
 * 当 Thread 因未捕获的异常而突然终止时，调用处理程序的接口。
 * 
 */
public class xxxUncaughtExceptionHandler implements UncaughtExceptionHandler {

    /** 系统原有的{@link Thread.UncaughtExceptionHandler}处理类。 */
    private Thread.UncaughtExceptionHandler mSystemDefaultHandler = null;

    public static final String TAG = "xxxUncaughtExceptionHandler";
    /** 扩展的异常处理handler。 */
    private Thread.UncaughtExceptionHandler mExtraHandler = null;

    /** 单例模式下的自身实例。 */
    private static xxxUncaughtExceptionHandler mInstance = null;

    /** 程序的 Context 对象 */
    private Context mContext;

    /** 用来存储设备信息和异常信息 */
    private Map<String, String> infos = new HashMap<String, String>();

    /** 用于格式化日期,作为日志文件名的一部分 */
    private DateFormat formatter = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss", Locale.getDefault());

    /** 设置构造方法为私有，不对外开放。 */
    private xxxUncaughtExceptionHandler() {
    }

    /**
     * 获得异常捕获器的一个单例。
     * 
     * @return 异常捕获器的一个单例。
     */
    public static xxxUncaughtExceptionHandler getInstance() {
        if (mInstance == null) {
            mInstance = new xxxUncaughtExceptionHandler();
        }
        return mInstance;
    }

    @Override
    public void uncaughtException(Thread thread, Throwable ex) {
        // 产品首先处理异常
        handleException(ex);
        if (mExtraHandler != null) {
            mExtraHandler.uncaughtException(thread, ex);
        } else if (mSystemDefaultHandler != null) {
            // 如果用户没有处理则让系统默认的异常处理器来处理
            mSystemDefaultHandler.uncaughtException(thread, ex);
        }else {  
            try {  
                Thread.sleep(3000);  
            } catch (InterruptedException e) {  
                Log.e(TAG, "error : ", e);  
            }  

            // 退出程序,注释下面的重启启动程序代码
            Utils.printLog("xxxUncaughtExceptionHandler-globalException", "exit");
            android.os.Process.killProcess(android.os.Process.myPid());  
            System.exit(1);  

        // 捕获了全局异常，进行后续处理，退出程序。
        }
    }

    /**
     * 获得系统原有的异常捕获handler。
     * 
     * @return 系统原有的异常捕获handler。
     */
    public Thread.UncaughtExceptionHandler getDefaultUncaughtExceptionHandler() {
        return mSystemDefaultHandler;
    }

    /**
     * 初始化全局异常捕获。
     */
    public void init(Context context) {
        mContext = context;
        // 先将系统默认的UncaughtException处理器保存下来。
        mSystemDefaultHandler = Thread.getDefaultUncaughtExceptionHandler();
        // 设置当前类为程序的默认异常处理类。
        Thread.setDefaultUncaughtExceptionHandler(this);
    }

    /**
     * 设置额外的全局异常捕获。
     * 
     * @param handler
     *            全局异常捕获实例。
     */
    final public void setExtraHandler(Thread.UncaughtExceptionHandler handler) {
        mExtraHandler = handler;
    }

    /**
     * 自定义的错误处理，收集错误信息。
     * 
     * @param ex
     *            产生的异常。
     * @return 如果异常得到了处理，则返回true；否则返回false。
     */
    private boolean handleException(Throwable ex) {
        if (ex == null) { // 异常为null的话，不进行处理。
            return false;
        }
        new Thread() {

            @Override
            public void run() {
                Looper.prepare();
                // 记录程序的崩溃时间。
                long crashedTime = new Date().getTime();
                Utils.printLog("xxxUncaughtExceptionHandler-handleException", 
                        "app crashed at " + crashedTime);
                if (xxxConfig.newInstance().isTrack() && xxxConfig.newInstance().getxxxTrackTool() != null) {
                    xxxConfig.newInstance().getxxxTrackTool().recordCrashedTime(crashedTime);
                }
Looper.prepare();  
Toast.makeText(mContext, "很抱歉，程序出现异常，即将退出。", Toast.LENGTH_LONG).show();  
Looper.loop();  
            };
        }.start();
        // 收集设备参数信息
        collectDeviceInfo(mContext);
        // 保存日志文件
        saveCrashInfo2File(ex);
        return true;
    }

    /**
     * 收集设备参数信息
     * 
     * @param ctx
     */
    public void collectDeviceInfo(Context ctx) {
        try {
            // 检索已安装的应用程序包的整体信息
            PackageManager pm = ctx.getPackageManager();
            PackageInfo pi = pm.getPackageInfo(ctx.getPackageName(), PackageManager.GET_ACTIVITIES);

            if (pi != null) {
                String versionName = pi.versionName == null ? "null" : pi.versionName;
                String versionCode = pi.versionCode + "";
                infos.put("versionName", versionName);
                infos.put("versionCode", versionCode);
            }
        } catch (NameNotFoundException e) {
            Utils.printException(e);
        }

        Field[] fields = Build.class.getDeclaredFields();
        for (Field field : fields) {
            try {
                field.setAccessible(true);
                infos.put(field.getName(), field.get(null).toString());
                Utils.printLog(TAG, field.getName() + " : " + field.get(null));
            } catch (Exception e) {
                Utils.printException(e);
            }
        }
    }

    /**
     * 保存错误信息到文件中
     * 
     * @param ex
     * @return 返回文件名称,便于将文件传送到服务器
     */
    private String saveCrashInfo2File(Throwable ex) {
        StringBuffer sb = new StringBuffer();
        // 追加设备信息
        for (Map.Entry<String, String> entry : infos.entrySet()) {
            String key = entry.getKey();
            String value = entry.getValue();
            sb.append(key + "=" + value + "\n");
        }
        // 追加错误信息
        Writer writer = new StringWriter();
        PrintWriter printWriter = new PrintWriter(writer);
        ex.printStackTrace(printWriter);
        Throwable cause = ex.getCause();
        while (cause != null) {
            cause.printStackTrace(printWriter);
            cause = cause.getCause();
        }
        printWriter.close();

        String result = writer.toString();
        sb.append(result);
        // 写入日志
        try {
            long timestamp = System.currentTimeMillis();
            String time = formatter.format(new Date());
            String fileName = "crash-" + time + "-" + timestamp + ".log";

            if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
                String path = "/sdcard/rytong/crash/";
                File dir = new File(path);
                if (!dir.exists()) {
                    dir.mkdirs();
                }
                // 写入文件
                FileOutputStream fos = new FileOutputStream(path + fileName);
                fos.write(sb.toString().getBytes());
                fos.close();
            }

            return fileName;
        } catch (Exception e) {
            Utils.printException(e);
        }

        return null;
    }
}

之后应用自定义APP全局管理类，设置三种方式的UncaughtExceptionHandler处理。1.xxxUncaughtExceptionHandler mUncaughtHandler自定义的崩溃异常处理类。
2.mUncaughtHandler.getDefaultUncaughtExceptionHandler();系统原有的异常捕获handler
3.setExtraHandler(Thread.UncaughtExceptionHandler handler)参数传递一个扩展的异常处理handler

/**
 * 自定义的程序管理类。<br />
 * 记得在主工程的AndroidManifest.xml中修改：<br /><br />
 * {@literal <application android:name="com.android.xxxApplication" ...>}<br />
 * {@literal </application>}<br /><br/>
 * 或者使用本类的继承类。
 */
public class ***Application extends Application {

    /** 异常处理器。 */
    private xxxUncaughtExceptionHandler mUncaughtHandler = null;

    @Override
    public void onCreate() {
        super.onCreate();
        mUncaughtHandler = xxxUncaughtExceptionHandler.getInstance();
        mUncaughtHandler.init(getApplicationContext());
    }

    /**
     * 获得系统原有的异常捕获handler。
     * @return 系统原有的异常捕获handler。
     */
    final public Thread.UncaughtExceptionHandler getDefaultUncaughtExceptionHandler(){
        return mUncaughtHandler.getDefaultUncaughtExceptionHandler();
    }

    /**
     * 设置额外的全局异常捕获实例。
     * @param handler 额外的全局异常捕获实例。
     */
    final public void setExtraHandler(Thread.UncaughtExceptionHandler handler){
        mUncaughtHandler.setExtraHandler(handler);
    }
}

最后就是在我们的具体项目中应用他：

public class MainApplication extends xxxApplication {

    @Override
    public void onCreate() {
        super.onCreate();
        setExtraHandler(new Thread.UncaughtExceptionHandler() {

            @Override
            public void uncaughtException(Thread thread, Throwable ex) {
                Utils.printLog("uncaughtException", "额外的全局异常处理。");
            }
        });
    }
}

最后可结合：http://www.cnblogs.com/lee0oo0/archive/2012/11/28/2793052.html 部分内容参考此文章。