其實 ACRA 是一個崩潰處理的類庫，其功能就是收集App崩潰堆疊資訊，生成報告併發送到指定端，當然它也可以自己定製對應的操作，所以是個處理崩潰很不錯的庫。

ACRA Application Crash Reports for Android

其實在規定時間內崩潰次數超過規定值就自動清理 APP 資料這個功能在一些大型APP上都會有，因為這對於解決某些因本地資料導致的崩潰有很好的作用，使用者沒必要再進行解除安裝重灌，算是一個細節加分。

本文實現的是清理 APP 自身 data 目錄下的資料以及 SharedPreferences 裡面的資料，如需清理其它目錄下的資料請參考程式碼進行修改。

下面就說說怎麼去實現：

首先我們先在 build.gradle 裡面新增依賴：

dependencies {

    ...
    
    compile 'ch.acra:acra:4.7.0'
    
    ...
}

這裡要宣告一下為什麼要用4.7.0，寫這篇文章的時候最新的版本是4.9.2，其實幾個版本都試過，4.7.0最合我心意，因為這個版本在 Application 初始化資料崩潰也會被收集，4.7.0之後就不行，所以為了多一層保障而選擇了4.7.0。

接下來是自定義 Application：

@ReportsCrashes(
//一些ACRA的設定，具體參考ACRA文件，因為我們使用自定義Sender，所以這裡完全可以不用設定
// mailTo = "
 
[email protected]",
// mode = ReportingInteractionMode.TOAST,
// resToastText = R.string.crash_toast_text
)
public class MyApplication extends Application {
	private static Context context;

	@Override
	public void onCreate() {
		initACRA();
		super.onCreate();

		context = getApplicationContext();
	}

	public void initACRA() {
		if (!BuildConfig.DEBUG) {  //這裡判斷只有在非DEBUG下才清除資料，主要是為了在開發過程中能夠保留執行緒。
			ACRA.init(this);

			CrashHandler handler = new CrashHandler();
			ACRA.getErrorReporter().setReportSender(handler);  //在閃退時檢查是否要清空資料
		}
	}

	public static Context getContext(){
		return context;
	}

}
 

然後在 AndroidManifest.xml 裡面設定 Application：

<?xml version="1.0" encoding="utf-8"?>  
<manifest xmlns:android="http://schemas.android.com/apk/res/android"  
    package="...">  
    <application  
        ...  
        android:name="xxx.MyApplication">  
        ...  
    </application>  
</manifest> 

接下來就是自定義 ReportSender 類的程式碼：

public class CrashHandler implements ReportSender {
    @Override
    public void send(Context context, CrashReportData errorContent) throws ReportSenderException {
        //閃退,檢查是否需要清空資料
        new CrashModel().checkAndClearData();
    }
}

然後是崩潰處理 CrashModel 類的程式碼：

public class CrashModel {
    private static final String CRASH_TIME_FILE_NAME = "crash_time";
    //不能通過App.getPackageName來獲取包名，否則會有問題，只能預設為cn.campusapp.campus。所以對於debug或者運營版本，清資料會把release的清掉
    private static final String FILE_DIR = String.format("/data/data/%s/", BuildConfig.APPLICATION_ID);

    protected ArrayList<Long> mCrashTimes;
    Gson gson = new Gson();

    public CrashModel() {
        mCrashTimes = readCrashTimes();
        if (mCrashTimes == null) {
            mCrashTimes = new ArrayList<>();
            storeCrashTimes(mCrashTimes);
        }
    }


    public void checkAndClearData() {
        long timeNow = System.currentTimeMillis();

        if (checkClearData(timeNow, new ArrayList<>(mCrashTimes))) {
            //已經在5分鐘之內有三次閃退，需要清理資料
            try {
                clearData();
            }
            catch (Exception e) {
                //清空所有資料失敗
            }
        }
        else {
            mCrashTimes.add(timeNow);
            storeCrashTimes(mCrashTimes);
            //此次不需要清空資料, 崩潰此時：gson.toJson(mCrashTimes));
        }
    }

    private void storeCrashTimes(ArrayList<Long> crashTimes) {
        try {
            String str = gson.toJson(crashTimes);
            FileUtil.writeToFile(FILE_DIR + CRASH_TIME_FILE_NAME, str);
        }
        catch (Exception e) {
            //儲存閃退時間失敗
        }

    }

    private ArrayList<Long> readCrashTimes() {
        try {
            String timeStr = FileUtil.readFileContent(FILE_DIR + CRASH_TIME_FILE_NAME);
            return gson.fromJson(timeStr, new TypeToken<ArrayList<Long>>() {
            }.getType());
        }
        catch (Exception e) {
            //讀取閃退時間失敗
        }
        return null;
    }

    /**
     * 檢查是否需要清空資料，目前的清空策略是在5分鐘之內有三次閃退的就清空資料，也就是從後往前遍歷，只要前兩次閃退發生在5分鐘之內，就清空資料
     *
     * @return
     */
    private boolean checkClearData(long time, ArrayList<Long> crashTimes) {
        //Timber.i(gson.toJson(crashTimes));
        int count = 0;
        for (int i = crashTimes.size() - 1; i >= 0; i--) {
            long crashTime = crashTimes.get(i);
            if (time - crashTime <= 5 * 60 * 1000) {
                count++;
                if (count >= 2) {
                    break;
                }
            }
        }
        if (count >= 2) {
            //在5分鐘之內有三次閃退，這時候需要清空資料
            return true;
        } else {
            return false;
        }
    }

    /**
     * 清空資料，包括資料庫中的和SharedPreferences中的
     *
     * @throws Exception
     */
    private void clearData() throws Exception {
        //開始清理資料
        FileUtil.delFolderNew(FILE_DIR);
        SharedPreUtil.getInstance().Clear();
    }
}

這裡需要用到 Gson ，請從 GitHub 獲取 jar：

然後還有一個檔案處理類 FileUtil：

public class FileUtil {
	/**
     * Prints some data to a file using a BufferedWriter
     */
	public static boolean writeToFile(String filename, String data) {
		BufferedWriter bufferedWriter = null;
		try {
			// Construct the BufferedWriter object
			bufferedWriter = new BufferedWriter(new FileWriter(filename));
			// Start writing to the output stream
			bufferedWriter.write(data);
			return true;
		} catch (FileNotFoundException ex) {
			ex.printStackTrace();
		} catch (IOException ex) {
			ex.printStackTrace();
		} finally {
			// Close the BufferedWriter
			try {
				if (bufferedWriter != null) {
					bufferedWriter.flush();
					bufferedWriter.close();
				}
			} catch (IOException ex) {
				ex.printStackTrace();
			}
		}
		return false;
	}

	/**
	 * 讀檔案，並返回String
	 * @param strFileName 檔名
	 */
	public static String readFileContent(String strFileName) throws IOException {
		File file = new File(strFileName);
		return readFileContentAsString(file, null);
	}


	public static String readFileContentAsString(File file, String charsetName) throws IOException {
		if (!file.exists() || !file.isFile()) {
			throw new IOException("File to be readed not exist, file path : " + file.getAbsolutePath());
		}

		FileInputStream fileIn = null;
		InputStreamReader inReader = null;
		BufferedReader bReader = null;
		try {
			fileIn = new FileInputStream(file);
			inReader = charsetName == null ? new InputStreamReader(fileIn) : new InputStreamReader(fileIn, charsetName);
			bReader = new BufferedReader(inReader);
			StringBuffer content = new StringBuffer();
			char[] chBuffer = new char[1024];
			int readedNum = -1;
			while ((readedNum = bReader.read(chBuffer)) != -1) {
				content.append(chBuffer, 0, readedNum);
			}

			return content.toString();
		} finally {
			if (fileIn != null) {
				try {
					fileIn.close();
				} catch (IOException e) {
				}
			}

			if (bReader != null) {
				try {
					bReader.close();
				} catch (IOException e) {
				}
			}
		}
	}


	/**
	 * 刪除資料夾(調整後的)
	 *
	 * @param folderPath
	 *            String 資料夾路徑及名稱 如c:/fqf
	 */
	public static void delFolderNew(String folderPath) {
		try {
			delAllFileNew(folderPath); // 刪除完裡面所有內容

			File myFilePath = new File(folderPath);
			myFilePath.delete(); // 刪除空資料夾

		}
		catch (Exception e) {
			System.out.println("刪除資料夾操作出錯");
			e.printStackTrace();
		}
	}

	/**
	 * 刪除資料夾裡面的所有檔案(調整後的)
	 * @param path String 資料夾路徑 如 c:/fqf
	 */
	public static void delAllFileNew(String path) {
		File file = new File(path);
		if (!file.exists()) {
			return;
		}
		if (!file.isDirectory()) {
			return;
		}

		String[] tempList = file.list();
		File temp = null;
		String tempPath = "";

		for (int i = 0; i < tempList.length; i++) {
			if (path.endsWith(File.separator)) {
				temp = new File(path + tempList[i]);
				tempPath = path + tempList[i];
			}
			else {
				temp = new File(path + File.separator + tempList[i]);
				tempPath = path + File.separator + tempList[i];
			}
			if (temp.isFile()) {
				temp.delete();
			}
			if (temp.isDirectory()) {
				delFolderNew(tempPath);// 先刪除資料夾裡面的檔案
			}
		}
	}
}

（檔案處理工具類很實用，這裡只展示了要用到的一部分，可以自己再豐富其方法。）

最後還有一個處理 SharedPreferences 資料的工具類：

public class SharedPreUtil{
    private SharedPreUtil() {}
    private static SharedPreUtil sharedpreutil;

    public static SharedPreUtil getInstance() {
        if (sharedpreutil == null) {
            synchronized (SharedPreUtil.class) {
                sharedpreutil = new SharedPreUtil();
            }
        }
        return sharedpreutil;
    }

    public static void clear(){
        SharedPreferences prefer = MyApplication.getContext().getSharedPreferences(PREFERENCE_NAME, MODE_PRIVATE);
        SharedPreferences.Editor editor = prefers.edit();

        editor.remove("key1");
        editor.remove("key2");
        editor.remove("key3");
    }
}

其思路就是通過 MyApplication 獲得 context，然後獲取 SharedPreferences，再進行資料處理。

這裡只是對崩潰次數進行判斷以及本地資料清理處理，如果想進行上報崩潰記錄等操作，可以再自行研究下 ACRA 這個庫。