android -应用软件获取缓存大小和清除缓存功能

 

Android记录20-获取缓存大小和清除缓存功能

目录(?)[+]

获取缓存大小和清除缓存功能

前言

本篇博客要给大家分享的如何获取应用缓存的大小和清除缓存的功能，我们知道我们应用当中经常会产生一些数据，比如图片的缓存，数据库文件，配置文件等等。我们开发产品的时候，可能会有这样的一个需求清除应用内缓存的数据，可以让用户选择删除应用内产生的数据，这也是比较人性化的设计点。例如笔者参与开发的一款产品的设置界面就提供了清除缓存的功能，如下图所示：

在贴一大段代码之前，先普及Android的相关知识点：

先看360手机助手的一张图：

从上面这张图，我们可以看到这部手机有

系统文件（注：这个是系统的文件系统，不允许修改的）

内置SD卡（注：现在的手机基本上都有，就是我们所谓的ROM，是不可以移除的，RAM是我们手机的运行内存）

外置SD卡（注：这个就是我们的SD卡了，可以移除）

我们来考虑一个问题我们应用内的缓存数据存放在哪里？

我们的应用程序一般会产生以下几种类型的数据：

file-普通的文件存储

database-数据库文件（.db文件）

sharedPreference-配置数据(.xml文件）

cache-图片缓存文件

应用内数据的所有路径：

/data/data/com.xxx.xxx/cache - 应用内缓存（注：对应方法getCacheDir()）

/data/data/com.xxx.xxx/databases - 应用内数据库

/data/data/com.xxx.xxx/shared_prefs - 应用内配置文件

/data/data/com.xxx.xxx/files - 应用内文件（注：对应方法getFilesDir())

一种情况，我们没有外置SD卡，那么我们安装的应用安装在哪里？自然是手机中的内置SD卡里，具体路径是这样的：

那在Android是用什么方法来获取这个路径的：

如果我们手机有外置SD卡，我们也可以把应用安装在SD卡，但移除SD卡之后就不能使用了。

不管是内置还是外置SD卡，获取路径的方法是一样：

获取SD卡根目录：Environment.getExternalStorageDirectory().getAbsolutePath();

外部Cache路径：/mnt/sdcard/android/data/com.xxx.xxx/cache 一般存储缓存数据（注：通过getExternalCacheDir()获取）

外部File路径：/mnt/sdcard/android/data/com.xxx.xxx/files 存储长时间存在的数据 （注：通过getExternalFilesDir(String type)获取， type为特定类型，可以是以下任何一种

Environment.DIRECTORY_MUSIC, Environment.DIRECTORY_PODCASTS, Environment.DIRECTORY_RINGTONES, Environment.DIRECTORY_ALARMS, Environment.DIRECTORY_NOTIFICATIONS, Environment.DIRECTORY_PICTURES, or Environment.DIRECTORY_MOVIES. ）

最后提供一个工具类：

DataCleanManager.java

[java]  view plain copy

1. package com.infzm.daily.know.utils;  
2.   
3. /*  * 文 件 名:  DataCleanManager.java   
4.  * * 描    述:  主要功能有清除内/外缓存，清除数据库，清除sharedPreference，清除files和清除自定义目录   
5.  * */  
6.   
7. import java.io.File;  
8. import java.math.BigDecimal;  
9.   
10. import android.content.Context;  
11. import android.os.Environment;  
12. import android.text.TextUtils;  
13.   
14. /** * 本应用数据清除管理器 */  
15. public class DataCleanManager {  
16.     /** 
17.      * * 清除本应用内部缓存(/data/data/com.xxx.xxx/cache) * * 
18.      *  
19.      * @param context 
20.      */  
21.     public static void cleanInternalCache(Context context) {  
22.         deleteFilesByDirectory(context.getCacheDir());  
23.     }  
24.   
25.     /** 
26.      * * 清除本应用所有数据库(/data/data/com.xxx.xxx/databases) * * 
27.      *  
28.      * @param context 
29.      */  
30.     public static void cleanDatabases(Context context) {  
31.         deleteFilesByDirectory(new File("/data/data/"  
32.                 + context.getPackageName() + "/databases"));  
33.     }  
34.   
35.     /** 
36.      * * 清除本应用SharedPreference(/data/data/com.xxx.xxx/shared_prefs) * 
37.      *  
38.      * @param context 
39.      */  
40.     public static void cleanSharedPreference(Context context) {  
41.         deleteFilesByDirectory(new File("/data/data/"  
42.                 + context.getPackageName() + "/shared_prefs"));  
43.     }  
44.   
45.     /** 
46.      * * 按名字清除本应用数据库 * * 
47.      *  
48.      * @param context 
49.      * @param dbName 
50.      */  
51.     public static void cleanDatabaseByName(Context context, String dbName) {  
52.         context.deleteDatabase(dbName);  
53.     }  
54.   
55.     /** 
56.      * * 清除/data/data/com.xxx.xxx/files下的内容 * * 
57.      *  
58.      * @param context 
59.      */  
60.     public static void cleanFiles(Context context) {  
61.         deleteFilesByDirectory(context.getFilesDir());  
62.     }  
63.   
64.     /** 
65.      * * 清除外部cache下的内容(/mnt/sdcard/android/data/com.xxx.xxx/cache) 
66.      *  
67.      * @param context 
68.      */  
69.     public static void cleanExternalCache(Context context) {  
70.         if (Environment.getExternalStorageState().equals(  
71.                 Environment.MEDIA_MOUNTED)) {  
72.             deleteFilesByDirectory(context.getExternalCacheDir());  
73.         }  
74.     }  
75.     /** 
76.      * * 清除自定义路径下的文件，使用需小心，请不要误删。而且只支持目录下的文件删除 * * 
77.      *  
78.      * @param filePath 
79.      * */  
80.     public static void cleanCustomCache(String filePath) {  
81.         deleteFilesByDirectory(new File(filePath));  
82.     }  
83.   
84.     /** 
85.      * * 清除本应用所有的数据 * * 
86.      *  
87.      * @param context 
88.      * @param filepath 
89.      */  
90.     public static void cleanApplicationData(Context context, String... filepath) {  
91.         cleanInternalCache(context);  
92.         cleanExternalCache(context);  
93.         cleanDatabases(context);  
94.         cleanSharedPreference(context);  
95.         cleanFiles(context);  
96.         if (filepath == null) {  
97.             return;  
98.         }  
99.         for (String filePath : filepath) {  
100.             cleanCustomCache(filePath);  
101.         }  
102.     }  
103.   
104.     /** 
105.      * * 删除方法 这里只会删除某个文件夹下的文件，如果传入的directory是个文件，将不做处理 * * 
106.      *  
107.      * @param directory 
108.      */  
109.     private static void deleteFilesByDirectory(File directory) {  
110.         if (directory != null && directory.exists() && directory.isDirectory()) {  
111.             for (File item : directory.listFiles()) {  
112.                 item.delete();  
113.             }  
114.         }  
115.     }  
116.       
117.     // 获取文件  
118.     //Context.getExternalFilesDir() --> SDCard/Android/data/你的应用的包名/files/ 目录，一般放一些长时间保存的数据  
119.     //Context.getExternalCacheDir() --> SDCard/Android/data/你的应用包名/cache/目录，一般存放临时缓存数据  
120.     public static long getFolderSize(File file) throws Exception {  
121.         long size = 0;  
122.         try {  
123.             File[] fileList = file.listFiles();  
124.             for (int i = 0; i < fileList.length; i++) {  
125.                 // 如果下面还有文件  
126.                 if (fileList[i].isDirectory()) {  
127.                     size = size + getFolderSize(fileList[i]);  
128.                 } else {  
129.                     size = size + fileList[i].length();  
130.                 }  
131.             }  
132.         } catch (Exception e) {  
133.             e.printStackTrace();  
134.         }  
135.         return size;  
136.     }  
137.       
138.     /** 
139.      * 删除指定目录下文件及目录 
140.      *  
141.      * @param deleteThisPath 
142.      * @param filepath 
143.      * @return 
144.      */  
145.     public static void deleteFolderFile(String filePath, boolean deleteThisPath) {  
146.         if (!TextUtils.isEmpty(filePath)) {  
147.             try {  
148.                 File file = new File(filePath);  
149.                 if (file.isDirectory()) {// 如果下面还有文件  
150.                     File files[] = file.listFiles();  
151.                     for (int i = 0; i < files.length; i++) {  
152.                         deleteFolderFile(files[i].getAbsolutePath(), true);  
153.                     }  
154.                 }  
155.                 if (deleteThisPath) {  
156.                     if (!file.isDirectory()) {// 如果是文件，删除  
157.                         file.delete();  
158.                     } else {// 目录  
159.                         if (file.listFiles().length == 0) {// 目录下没有文件或者目录，删除  
160.                             file.delete();  
161.                         }  
162.                     }  
163.                 }  
164.             } catch (Exception e) {  
165.                 // TODO Auto-generated catch block  
166.                 e.printStackTrace();  
167.             }  
168.         }  
169.     }  
170.       
171.     /** 
172.      * 格式化单位 
173.      *  
174.      * @param size 
175.      * @return 
176.      */  
177.     public static String getFormatSize(double size) {  
178.         double kiloByte = size / 1024;  
179.         if (kiloByte < 1) {  
180.             return size + "Byte";  
181.         }  
182.   
183.         double megaByte = kiloByte / 1024;  
184.         if (megaByte < 1) {  
185.             BigDecimal result1 = new BigDecimal(Double.toString(kiloByte));  
186.             return result1.setScale(2, BigDecimal.ROUND_HALF_UP)  
187.                     .toPlainString() + "KB";  
188.         }  
189.   
190.         double gigaByte = megaByte / 1024;  
191.         if (gigaByte < 1) {  
192.             BigDecimal result2 = new BigDecimal(Double.toString(megaByte));  
193.             return result2.setScale(2, BigDecimal.ROUND_HALF_UP)  
194.                     .toPlainString() + "MB";  
195.         }  
196.   
197.         double teraBytes = gigaByte / 1024;  
198.         if (teraBytes < 1) {  
199.             BigDecimal result3 = new BigDecimal(Double.toString(gigaByte));  
200.             return result3.setScale(2, BigDecimal.ROUND_HALF_UP)  
201.                     .toPlainString() + "GB";  
202.         }  
203.         BigDecimal result4 = new BigDecimal(teraBytes);  
204.         return result4.setScale(2, BigDecimal.ROUND_HALF_UP).toPlainString()  
205.                 + "TB";  
206.     }  
207.       
208.       
209.     public static String getCacheSize(File file) throws Exception {  
210.         return getFormatSize(getFolderSize(file));  
211.     }  
212.       
213. }