Android Activity的增加和移除，全局异常重启APP

当展现一个Activity时，将其添加到集合中

当退出时，将集合中的Activity循环移除

    // 实例化一个集合来存储Activity
    private ArrayList<Activity> activityList;

    // activity管理：从列表中移除activity
    public void removeActivity(Activity activity) {
        activityList.remove(activity);
    }

    // activity管理：添加activity到列表
    public void addActivity(Activity activity) {
        activityList.add(activity);
    }

当程序发生异常的时候，我们需要重启APP来弥补，哎，都是眼泪啊

那就不得不说下全局异常捕获类，restartApp就是重启APP的方法

/**
 *  全局异常捕获句柄类
 */
public class CrashHandler implements UncaughtExceptionHandler {

    public static final String TAG = "CrashHandler";
    public static final boolean DEBUG = false; // 是否开启日志输出,在Debug状态下开启,
                                                // 在Release状态下关闭以提高程序性能

    private static CrashHandler crashHandler;

    private Thread.UncaughtExceptionHandler exceptionHandler; // 系统默认的UncaughtExceptionHandler
    private Context context;

    /**
     * 私有构造函数
     */
    private CrashHandler() {
    }

    /**
     * @return 单例
     */
    public static CrashHandler getInstance() {
        if (crashHandler == null) {
            crashHandler = new CrashHandler();
        }
        return crashHandler;
    }

    /**
     * @param context
     *            上下文对象
     */
    public void init(Context context) {
        this.context = context;
        exceptionHandler = Thread.getDefaultUncaughtExceptionHandler(); // 获取系统默认的UncaughtExceptionHandler
        Thread.setDefaultUncaughtExceptionHandler(this); // 设置本类对象crashHandler为程序的默认处理器
    }

    /**
     * 当异常发生时，捕获异常
     * 
     * @param thread
     *            线程
     * @param ex
     *            异常
     */
    @Override
    public void uncaughtException(Thread thread, Throwable ex) {
        if (!handleException(thread, ex) && exceptionHandler != null) {
            exceptionHandler.uncaughtException(thread, ex); // 如果用户没有处理则让系统默认的异常处理器来处理
        } else {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                SLog.Console("===============CrashHandler================");
                SLog.saveException(e);
                SLog.Console("==============CrashHandlerEnd==============");
            }
            MainApplication.getInstance().restartApp();
        }
    }

    /**
     * 自定义异常处理
     * 
     * @param ex
     *            异常
     * @return boolean 是否处理
     */
    private boolean handleException(Thread thread,  Throwable ex) {
        if (ex == null) {
            return true;
        }
         StringWriter sw = new StringWriter();  
            PrintWriter pw = new PrintWriter(sw, true);  
            ex.printStackTrace(pw);  
            pw.flush();  
            sw.flush();  
        this.saveInfo2File(ex); // 保存错误报告文件
        return true;
    }

    /**
     * 保存异常信息到文件中
     * 
     * @param ex
     *            异常
     * @return String 异常信息
     */
    public String saveInfo2File(final Throwable ex) {
        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();
        }

        String info = writer.toString();
        printWriter.close();
        FileUtil.saveLog("=================CrashInfo===============");
        FileUtil.saveLog(info);
        SLog.Console(info);
        FileUtil.saveLog("================CrashInfoEnd=============");
        return info;
    }

}

// 写在全局Application中
public void restartApp() {
        Intent intent = new Intent(MainApplication.getInstance(), BaseActivity.class);
        PendingIntent restartIntent = PendingIntent.getActivity(MainApplication.getInstance().getApplicationContext(),
                0, intent, Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK);
        // 退出程序
        AlarmManager mgr = (AlarmManager)   MainApplication.getInstance().getSystemService(Context.ALARM_SERVICE);
        mgr.set(AlarmManager.RTC, System.currentTimeMillis() + 1000, restartIntent); // 1秒钟后重启应用
        MainApplication.getInstance().finishProgram();
        android.os.Process.killProcess(android.os.Process.myPid());
        System.exit(10);
}

// activity管理：结束所有activity，彻底关闭应用
    public void finishProgram() {
        int size = activityList.size();
        for (int i = 0; i < size; i++) {
            Activity activity = activityList.get(i);
            if (null != activity) {
                activity.finish();
            }
        }
        activityList = new ArrayList<Activity>();
    }

在BaseActivity中的OnCreate()方法添加Activity

在BaseActivity中的onDestroy()方法移除Activity

// 添加Activity即可
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    requestWindowFeature(Window.FEATURE_NO_TITLE);
    MainApplication.getInstance().addActivity(this);
}

// 移除Activity
@Override
protected void onDestroy() {
    MainApplication.getInstance().removeActivity(this);
    super.onDestroy();
}

到这里也就基本实现了，Activity的集合，异常重启